Update docs for deployment on Vercel.

docs/chapter_array_and_linkedlist/array.md

@@ -0,0 +1,222 @@
+---
+comments: true
+---
+
+# 数组
+
+「数组 Array」是一种将 **相同类型元素** 存储在 **连续内存空间** 的数据结构，将元素在数组中的位置称为元素的「索引 Index」。
+
+![array_definition](array.assets/array_definition.png)
+
+<p style="text-align:center"> Fig. 数组定义与存储方式 </p>
+
+!!! note
+
+    观察上图，我们发现 **数组首元素的索引为 $0$** 。你可能会想，这并不符合日常习惯，首个元素的索引为什么不是 $1$ 呢，这不是更加自然吗？我认同你的想法，但请先记住这个设定，后面讲内存地址计算时，我会尝试解答这个问题。
+
+**数组有多种初始化写法。** 根据实际需要，选代码最短的那一种就好。
+
+=== "Java"
+
+    ```java title="array.java"
+    /* 初始化数组 */
+    int[] arr = new int[5]; // { 0, 0, 0, 0, 0 }
+    int[] nums = { 1, 3, 2, 5, 4 };
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    
+    ```
+
+=== "Python"
+
+    ```python title="array.py"
+    
+    ```
+
+## 数组优点
+
+**在数组中访问元素非常高效。** 这是因为在数组中，计算元素的内存地址非常容易。给定数组首个元素的地址、和一个元素的索引，利用以下公式可以直接计算得到该元素的内存地址，从而直接访问此元素。
+
+![array_memory_location_calculation](array.assets/array_memory_location_calculation.png)
+
+<p style="text-align:center"> Fig. 数组元素的内存地址计算 </p>
+
+```java title=""
+// 元素内存地址 = 数组内存地址 + 元素长度 * 元素索引
+elementAddr = firtstElementAddr + elementLength * elementIndex
+```
+
+**为什么数组元素索引从 0 开始编号？** 根据地址计算公式，**索引本质上表示的是内存地址偏移量**，首个元素的地址偏移量是 $0$ ，那么索引是 $0$ 也就很自然了。
+
+访问元素的高效性带来了许多便利。例如，我们可以在 $O(1)$ 时间内随机获取一个数组中的元素。
+
+=== "Java"
+
+    ```java title="array.java"
+    /* 随机返回一个数组元素 */
+    int randomAccess(int[] nums) {
+        int randomIndex = ThreadLocalRandom.current().
+                          nextInt(0, nums.length);
+        int randomNum = nums[randomIndex];
+        return randomNum;
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    
+    ```
+
+=== "Python"
+
+    ```python title="array.py"
+    
+    ```
+
+## 数组缺点
+
+**数组在初始化后长度不可变。** 由于系统无法保证数组之后的内存空间是可用的，因此数组长度无法扩展。而若希望扩容数组，则需新建一个数组，然后把原数组元素依次拷贝到新数组，在数组很大的情况下，这是非常耗时的。
+
+=== "Java"
+
+    ```java title="array.java"
+    /* 扩展数组长度 */
+    int[] extend(int[] nums, int enlarge) {
+        // 初始化一个扩展长度后的数组
+        int[] res = new int[nums.length + enlarge];
+        // 将原数组中的所有元素复制到新数组
+        for (int i = 0; i < nums.length; i++) {
+            res[i] = nums[i];
+        }
+        // 返回扩展后的新数组
+        return res;
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    
+    ```
+
+=== "Python"
+
+    ```python title="array.py"
+    
+    ```
+
+**数组中插入或删除元素效率低下。** 假设我们想要在数组中间某位置插入一个元素，由于数组元素在内存中是 “紧挨着的” ，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。删除元素也是类似，需要把此索引之后的元素都向前移动一位。总体看有以下缺点：
+
+- **时间复杂度高：** 数组的插入和删除的平均时间复杂度均为 $O(N)$ ，其中 $N$ 为数组长度。
+- **丢失元素或：** 由于数组的长度不可变，因此在插入元素后，数组原来的末尾元素会丢失。
+- **内存浪费：** 我们一般会初始化一个比较长的数组，只用前面一部分，这样在插入数据时，丢失的末尾元素都是我们不关心的，但这样做同时也会造成内存空间的浪费。
+
+![array_insert_remove_element](array.assets/array_insert_remove_element.png)
+
+<p style="text-align:center"> Fig. 在数组中插入与删除元素 </p>
+
+=== "Java"
+
+    ```java title="array.java"
+    /* 在数组的索引 index 处插入元素 num */
+    void insert(int[] nums, int num, int index) {
+        // 把索引 index 以及之后的所有元素向后移动一位
+        for (int i = nums.length - 1; i >= index; i--) {
+            nums[i] = nums[i - 1];
+        }
+        // 将 num 赋给 index 处元素
+        nums[index] = num;
+    }
+    
+    /* 删除索引 index 处元素 */
+    void remove(int[] nums, int index) {
+        // 把索引 index 之后的所有元素向前移动一位
+        for (int i = index; i < nums.length - 1; i++) {
+            nums[i] = nums[i + 1];
+        }
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    
+    ```
+
+=== "Python"
+
+    ```python title="array.py"
+    
+    ```
+
+## 数组常用操作
+
+**数组遍历。** 以下介绍两种常用的遍历方法。
+
+=== "Java"
+
+    ```java title="array.java"
+    /* 遍历数组 */
+    void traverse(int[] nums) {
+        int count = 0;
+        // 通过索引遍历数组
+        for (int i = 0; i < nums.length; i++) {
+            count++;
+        }
+        // 直接遍历数组
+        for (int num : nums) {
+            count++;
+        }
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    
+    ```
+
+=== "Python"
+
+    ```python title="array.py"
+    
+    ```
+
+**数组查找。** 通过遍历数组，查找数组内的指定元素，并输出对应索引。
+
+=== "Java"
+
+    ```java title="array.java"
+    /* 在数组中查找指定元素 */
+    int find(int[] nums, int target) {
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] == target)
+                return i;
+        }
+        return -1;
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    
+    ```
+
+=== "Python"
+
+    ```python title="array.py"
+    
+    ```
+
+## 数组典型应用
+
+**随机访问。** 如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。
+
+**二分查找。** 例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的 “翻开中间，排除一半” 的方式，来实现一个查电子字典的算法。
+
+**深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。

docs/chapter_array_and_linkedlist/linked_list.md

@@ -0,0 +1,222 @@
+---
+comments: true
+---
+
+# 链表
+
+!!! note "引言"
+
+    内存空间是所有程序的公共资源，排除已占用的内存，空闲内存往往是散落在内存各处的。我们知道，存储数组需要内存空间连续，当我们需要申请一个很大的数组时，系统不一定存在这么大的连续内存空间。而链表则更加灵活，不需要内存是连续的，只要剩余内存空间大小够用即可。
+
+「链表 Linked List」是一种线性数据结构，其中每个元素都是单独的对象，各个元素（一般称为结点）之间通过指针连接。由于结点中记录了连接关系，因此链表的存储方式相比于数组更加灵活，系统不必保证内存地址的连续性。
+
+链表的「结点 Node」包含两项数据，一是结点「值 Value」，二是指向下一结点的「指针 Pointer」（或称「引用 Reference」）。
+
+![linkedlist_definition](linked_list.assets/linkedlist_definition.png)
+
+<p style="text-align:center"> Fig. 链表定义与存储方式 </p>
+
+=== "Java"
+
+    ```java title=""
+    /* 链表结点类 */
+    class ListNode {
+        int val;        // 结点值
+        ListNode next;  // 指向下一结点的指针（引用）
+        ListNode(int x) { val = x; }  // 构造函数
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    
+    ```
+
+=== "Python"
+
+    ```python title=""
+    """ 链表结点类 """ 
+    class ListNode:
+        def __init__(self, x):
+            self.val = x      # 结点值
+            self.next = None  # 指向下一结点的指针（引用）
+    ```
+
+**尾结点指向什么？** 我们一般将链表的最后一个结点称为「尾结点」，其指向的是「空」，在 Java / C++ / Python 中分别记为 `null` / `nullptr` / `None` 。在不引起歧义下，本书都使用 `null` 来表示空。
+
+**链表初始化方法。** 建立链表分为两步，第一步是初始化各个结点对象，第二步是构建引用指向关系。完成后，即可以从链表的首个结点（即头结点）出发，访问其余所有的结点。
+
+!!! tip
+
+    我们通常将头结点当作链表的代称，例如头结点 `head` 和链表 `head` 实际上是同义的。
+
+=== "Java"
+
+    ```java title=""
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各个结点 
+    ListNode n0 = new ListNode(1);
+    ListNode n1 = new ListNode(3);
+    ListNode n2 = new ListNode(2);
+    ListNode n3 = new ListNode(5);
+    ListNode n4 = new ListNode(4);
+    // 构建引用指向
+    n0.next = n1;
+    n1.next = n2;
+    n2.next = n3;
+    n3.next = n4;
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    
+    ```
+
+=== "Python"
+
+    ```python title=""
+    
+    ```
+
+## 链表优点
+
+**在链表中，插入与删除结点的操作效率高。** 例如，如果想在链表中间的两个结点 `A` , `B` 之间插入一个新结点 `P` ，我们只需要改变两个结点指针即可，时间复杂度为 $O(1)$ ，相比数组的插入操作高效很多。在链表中删除某个结点也很方便，只需要改变一个结点指针即可。
+
+![linkedlist_insert_remove_node](linked_list.assets/linkedlist_insert_remove_node.png)
+
+<p style="text-align:center"> Fig. 在链表中插入与删除结点 </p>
+
+=== "Java"
+
+    ```java title=""
+    /* 在链表的结点 n0 之后插入结点 P */
+    void insert(ListNode n0, ListNode P) {
+        ListNode n1 = n0.next;
+        n0.next = P;
+        P.next = n1;
+    }
+    
+    /* 删除链表的结点 n0 之后的首个结点 */
+    void remove(ListNode n0) {
+        if (n0.next == null)
+            return;
+        // n0 -> P -> n1
+        ListNode P = n0.next;
+        ListNode n1 = P.next;
+        n0.next = n1;
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    
+    ```
+
+=== "Python"
+
+    ```python title=""
+    
+    ```
+
+## 链表缺点
+
+**链表访问结点效率低。** 上节提到，数组可以在 $O(1)$ 时间下访问任意元素，但链表无法直接访问任意结点。这是因为计算机需要从头结点出发，一个一个地向后遍历到目标结点。例如，倘若想要访问链表索引为 `index` （即第 `index + 1` 个）的结点，那么需要 `index` 次访问操作。
+
+=== "Java"
+
+    ```java title=""
+    /* 访问链表中索引为 index 的结点 */
+    ListNode access(ListNode head, int index) {
+        for (int i = 0; i < index; i++) {
+            head = head.next;
+            if (head == null)
+                return null;
+        }
+        return head;
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    
+    ```
+
+=== "Python"
+
+    ```python title=""
+    
+    ```
+
+**链表的内存占用多。** 链表以结点为单位，每个结点除了保存值外，还需额外保存指针（引用）。这意味着同样数据量下，链表比数组需要占用更多内存空间。
+
+## 链表常用操作
+
+**遍历链表查找。** 遍历链表，查找链表内值为 `target` 的结点，输出结点在链表中的索引。
+
+=== "Java"
+
+    ```java title=""
+    /* 在链表中查找值为 target 的首个结点 */
+    int find(ListNode head, int target) {
+        int index = 0;
+        while (head != null) {
+            if (head.val == target)
+                return index;
+            head = head.next;
+            index++;
+        }
+        return -1;
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    
+    ```
+
+=== "Python"
+
+    ```python title=""
+    
+    ```
+
+## 常见链表类型
+
+**单向链表。** 即上述介绍的普通链表。单向链表的结点有「值」和指向下一结点的「指针（引用）」两项数据。我们将首个结点称为头结点，尾结点指向 `null` 。
+
+**环形链表。** 如果我们令单向链表的尾结点指向头结点（即首尾相接），则得到一个环形链表。在环形链表中，我们可以将任意结点看作是头结点。
+
+**双向链表。** 单向链表仅记录了一个方向的指针（引用），在双向链表的结点定义中，同时有指向下一结点（后继结点）和上一结点（前驱结点）的「指针（引用）」。双向链表相对于单向链表更加灵活，即可以朝两个方向遍历链表，但也需要占用更多的内存空间。
+
+=== "Java"
+
+    ```java title=""
+    /* 双向链表结点类 */
+    class ListNode {
+        int val;        // 结点值
+        ListNode next;  // 指向后继结点的指针（引用）
+        ListNode prev;  // 指向前驱结点的指针（引用）
+        ListNode(int x) { val = x; }  // 构造函数
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    
+    ```
+
+=== "Python"
+
+    ```python title=""
+    
+    ```
+
+![linkedlist_common_types](linked_list.assets/linkedlist_common_types.png)
+
+<p style="text-align:center"> Fig. 常见链表类型 </p>

docs/chapter_array_and_linkedlist/list.md

@@ -0,0 +1,273 @@
+---
+comments: true
+---
+
+# 列表
+
+**由于长度不可变，数组的实用性大大降低。** 在很多情况下，我们事先并不知道会输入多少数据，这就为数组长度的选择带来了很大困难。长度选小了，需要在添加数据中频繁地扩容数组；长度选大了，又造成内存空间的浪费。
+
+为了解决此问题，诞生了一种被称为「列表 List」的数据结构。列表可以被理解为长度可变的数组，因此也常被称为「动态数组 Dynamic Array」。列表基于数组实现，继承了数组的优点，同时还可以在程序运行中实时扩容。在列表中，我们可以自由地添加元素，而不用担心超过容量限制。
+
+## 列表常用操作
+
+**初始化列表。** 我们通常使用 `Integer[]` 包装类和 `Arrays.asList()` 作为中转，来初始化一个带有初始值的列表。
+
+=== "Java"
+
+    ```java title="list.java"
+    /* 初始化列表 */
+    // 注意数组的元素类型是 int[] 的包装类 Integer[]
+    Integer[] numbers = new Integer[] { 1, 3, 2, 5, 4 };
+    List<Integer> list = new ArrayList<>(Arrays.asList(numbers));
+    ```
+
+=== "C++"
+
+    ```cpp title="list.cpp"
+
+    ```
+
+=== "Python"
+
+    ```python title="list.py"
+    
+    ```
+
+**访问与更新元素。** 列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。
+
+=== "Java"
+
+    ```java title="list.java"
+    /* 访问元素 */
+    int num = list.get(1);  // 访问索引 1 处的元素
+
+    /* 更新元素 */
+    list.set(1, 0);  // 将索引 1 处的元素更新为 0
+    ```
+
+=== "C++"
+
+    ```cpp title="list.cpp"
+
+    ```
+
+=== "Python"
+
+    ```python title="list.py"
+    
+    ```
+
+**在列表中添加、插入、删除元素。** 相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
+
+=== "Java"
+
+    ```java title="list.java"
+    /* 清空列表 */
+    list.clear();
+
+    /* 尾部添加元素 */
+    list.add(1);
+    list.add(3);
+    list.add(2);
+    list.add(5);
+    list.add(4);
+
+    /* 中间插入元素 */
+    list.add(3, 6);  // 在索引 3 处插入数字 6
+
+    /* 删除元素 */
+    list.remove(3);  // 删除索引 3 处的元素
+    ```
+
+=== "C++"
+
+    ```cpp title="list.cpp"
+
+    ```
+
+=== "Python"
+
+    ```python title="list.py"
+    
+    ```
+
+**遍历列表。** 与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
+
+=== "Java"
+
+    ```java title="list.java"
+    /* 通过索引遍历列表 */
+    int count = 0;
+    for (int i = 0; i < list.size(); i++) {
+        count++;
+    }
+
+    /* 直接遍历列表元素 */
+    count = 0;
+    for (int n : list) {
+        count++;
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="list.cpp"
+
+    ```
+
+=== "Python"
+
+    ```python title="list.py"
+    
+    ```
+
+**拼接两个列表。** 再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。
+
+=== "Java"
+
+    ```java title="list.java"
+    /* 拼接两个列表 */
+    List<Integer> list1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));
+    list.addAll(list1);  // 将列表 list1 拼接到 list 之后
+    ```
+
+=== "C++"
+
+    ```cpp title="list.cpp"
+
+    ```
+
+=== "Python"
+
+    ```python title="list.py"
+    
+    ```
+
+**排序列表。** 排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
+
+=== "Java"
+
+    ```java title="list.java"
+    /* 排序列表 */
+    Collections.sort(list);  // 排序后，列表元素从小到大排列
+    ```
+
+=== "C++"
+
+    ```cpp title="list.cpp"
+
+    ```
+
+=== "Python"
+
+    ```python title="list.py"
+    
+    ```
+
+## 列表简易实现 *
+
+为了帮助加深对列表的理解，我们在此提供一个列表的简易版本的实现。需要关注三个核心点：
+
+- **初始容量：** 选取一个合理的数组的初始容量 `initialCapacity` 。在本示例中，我们选择 10 作为初始容量。
+- **数量记录：** 需要声明一个变量 `size` ，用来记录列表当前有多少个元素，并随着元素插入与删除实时更新。根据此变量，可以定位列表的尾部，以及判断是否需要扩容。
+- **扩容机制：** 插入元素有可能导致超出列表容量，此时需要扩容列表，方法是建立一个更大的数组来替换当前数组。需要给定一个扩容倍数 `extendRatio` ，在本示例中，我们规定每次将数组扩容至之前的 2 倍。
+
+本示例是为了帮助读者对如何实现列表产生直观的认识。实际编程语言中，列表的实现远比以下代码复杂且标准，感兴趣的读者可以查阅源码学习。
+
+=== "Java"
+
+    ```java title="my_list.java"
+    /* 列表类简易实现 */
+    class MyList {
+        int[] nums;               // 数组（存储列表元素）
+        int initialCapacity = 10; // 列表初始容量
+        int size = 0;             // 列表长度（即当前元素数量）
+        int extendRatio = 2;      // 每次列表扩容的倍数
+
+        /* 构造函数 */
+        public MyList() {
+            nums = new int[initialCapacity];
+        }
+
+        /* 获取列表容量 */
+        public int size() {
+            return size;
+        }
+
+        /* 获取列表长度（即当前元素数量） */
+        public int capacity() {
+            return nums.length;
+        }
+
+        /* 访问元素 */
+        public int get(int index) {
+            // 索引如果越界则抛出异常，下同
+            if (index >= size)
+                throw new IndexOutOfBoundsException("索引越界");
+            return nums[index];
+        }
+
+        /* 更新元素 */
+        public void set(int index, int num) {
+            if (index >= size)
+                throw new IndexOutOfBoundsException("索引越界");
+            nums[index] = num;
+        }
+
+        /* 尾部添加元素 */
+        public void add(int num) {
+            // 元素数量超出容量时，触发扩容机制
+            if (size == nums.length)
+                extendCapacity();
+            nums[size] = num;
+            // 更新元素数量
+            size++;
+        }
+
+        /* 中间插入元素 */
+        public void add(int index, int num) {
+            if (index >= size)
+                throw new IndexOutOfBoundsException("索引越界");
+            // 元素数量超出容量时，触发扩容机制
+            if (size == nums.length)
+                extendCapacity();
+            // 索引 i 以及之后的元素都向后移动一位
+            for (int j = size - 1; j >= index; j--) {
+                nums[j + 1] = nums[j];
+            }
+            nums[index] = num;
+            // 更新元素数量
+            size++;
+        }
+
+        /* 删除元素 */
+        public void remove(int index) {
+            if (index >= size)
+                throw new IndexOutOfBoundsException("索引越界");
+            // 索引 i 之后的元素都向前移动一位
+            for (int j = index; j < size - 1; j++) {
+                nums[j] = nums[j + 1];
+            }
+            // 更新元素数量
+            size--;
+        }
+
+        /* 列表扩容 */
+        public void extendCapacity() {
+            // 新建一个长度为 size 的数组，并将原数组拷贝到新数组
+            nums = Arrays.copyOf(nums, nums.length * extendRatio);
+        }
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="my_list.cpp"
+
+    ```
+
+=== "Python"
+
+    ```python title="my_list.py"
+    
+    ```

docs/chapter_array_and_linkedlist/summary.md

@@ -0,0 +1,41 @@
+---
+comments: true
+---
+
+# 小结
+
+- 数组和链表是两种基本数据结构，代表了数据在计算机内存中的两种存储方式，即连续空间存储和离散空间存储。两者的优缺点呈现出此消彼长的关系。
+- 数组支持随机访问、内存空间占用小；但插入与删除元素效率低，且初始化后长度不可变。
+- 链表可通过更改指针实现高效的结点插入与删除，并且可以灵活地修改长度；但结点访问效率低、占用内存多。常见的链表类型有单向链表、循环链表、双向链表。
+- 列表又称动态数组，是基于数组实现的一种数据结构，其保存了数组的优势，且可以灵活改变长度。列表的出现大大提升了数组的实用性，但副作用是会造成部分内存空间浪费。
+
+## 数组 VS 链表
+
+<p style="text-align:center"> Table. 数组与链表特点对比 </p>
+
+<div class="center-table" markdown>
+
+|              | 数组                     | 链表         |
+| ------------ | ------------------------ | ------------ |
+| 存储方式     | 连续内存空间             | 离散内存空间 |
+| 数据结构长度 | 长度不可变               | 长度可变     |
+| 内存使用率   | 占用内存少、缓存局部性好 | 占用内存多   |
+| 优势操作     | 随机访问                 | 插入、删除   |
+
+</div>
+
+!!! tip
+
+    「缓存局部性（Cache locality）」涉及到了计算机操作系统，在本书不做展开介绍，建议有兴趣的同学 Google / Baidu 一下。
+
+<p style="text-align:center"> Table. 数组与链表操作时间复杂度 </p>
+
+<div class="center-table" markdown>
+
+| 操作     | 数组   | 链表   |
+| ------- | ------ | ------ |
+| 访问元素 | $O(1)$ | $O(N)$ |
+| 添加元素 | $O(N)$ | $O(1)$ |
+| 删除元素 | $O(N)$ | $O(1)$ |
+
+</div>