art update: heap

Author: ConardLi

docs/.vuepress/config.js

@@ -1,25 +1,18 @@
 module.exports = {
     title: 'awesome-coding-js',
     description: '用JavaScript实现的算法和数据结构',
+    base: '/docs/',
     themeConfig: {
         sidebarDepth: 2,
         lastUpdated: 'Last Updated',
         nav: [
             { text: '数据结构分类', link: '/dataStructure/' },
-            { text: '博客', link: 'http://www.conardli.top' },
+            { text: '博客', link: 'http://www.conardli.top/blog/article/' },
             { text: 'github', link: 'https://github.com/ConardLi' },
         ],
         sidebar: {
             '/dataStructure/': [
                 '/dataStructure/',
-                {
-                    title: '堆',
-                    children: [
-                        '/dataStructure/堆/堆的基本操作',
-                        '/dataStructure/堆/数据流中的中位数',
-                        '/dataStructure/堆/最小的k个数',
-                    ]
-                },
                 {
                     title: '二叉树',
                     children: [
@@ -41,7 +34,29 @@ module.exports = {
                         '/dataStructure/二叉树/二叉树的下一个节点',
                         '/dataStructure/二叉树/树的子结构',
                     ]
-                }
+                },
+                {
+                    title: '堆',
+                    children: [
+                        '/dataStructure/堆/堆的基本操作',
+                        '/dataStructure/堆/数据流中的中位数',
+                        '/dataStructure/堆/最小的k个数',
+                    ]
+                },
+                {
+                    title: '链表',
+                    children: [
+                        '/dataStructure/链表/从尾到头打印链表',
+                        '/dataStructure/链表/反转链表',
+                        '/dataStructure/链表/复杂链表的复制',
+                        '/dataStructure/链表/合并两个排序的链表',
+                        '/dataStructure/链表/链表倒数第k个节点',
+                        '/dataStructure/链表/链表中环的入口节点',
+                        '/dataStructure/链表/两个链表的第一个公共节点',
+                        '/dataStructure/链表/圈圈中最后剩下的数字',
+                        '/dataStructure/链表/删除链表中的节点or重复的节点',
+                    ]
+                },
             ]
         }
     }

docs/dataStructure/链表/两个链表的第一个公共节点.md

@@ -0,0 +1,66 @@
+---
+{
+  "title": "两个链表的第一个公共节点",
+}
+---
+## 题目
+
+输入两个链表，找出它们的第一个公共结点。
+
+## 思路
+
+
+- 1.先找到两个链表的长度`length1`、`length2`
+
+- 2.让长一点的链表先走`length2-length1`步，让长链表和短链表起点相同
+
+- 3.两个链表一起前进，比较获得第一个相等的节点
+
+- 时间复杂度`O(length1+length2)` 空间复杂度`O(0)`
+
+![](/dist/img/链表公共节点.png)
+
+
+## 代码
+
+```js
+function FindFirstCommonNode(pHead1, pHead2) {
+      if (!pHead1 || !pHead2) { return null; }
+      // 获取链表长度
+      let length1 = getLength(pHead1);
+      let length2 = getLength(pHead2);
+      // 长链表先行
+      let lang, short, interval;
+      if (length1 > length2) {
+        lang = pHead1;
+        short = pHead2;
+        interval = length1 - length2;
+      } else {
+        lang = pHead2;
+        short = pHead1;
+        interval = length2 - length1;
+      }
+      while (interval--) {
+        lang = lang.next;
+      }
+      // 找相同节点
+      while (lang) {
+        if (lang === short) {
+          return lang;
+        }
+        lang = lang.next;
+        short = short.next;
+      }
+      return null;
+    }
+
+    function getLength(head) {
+      let current = head;
+      let result = 0;
+      while (current) {
+        result++;
+        current = current.next;
+      }
+      return result;
+    }
+```

docs/dataStructure/链表/从尾到头打印链表.md

@@ -0,0 +1,42 @@
+---
+{
+  "title": "从尾到头打印链表",
+}
+---
+
+
+## 题目
+
+输入一个链表，按链表值从尾到头的顺序返回一个`ArrayList`。
+
+## 分析
+
+要了解链表的数据结构：
+
+`val`属性存储当前的值，`next`属性存储下一个节点的引用。
+
+要遍历链表就是不断找到当前节点的`next`节点，当`next`节点是`null`时，说明是最后一个节点，停止遍历。
+
+因为是从尾到头的顺序，使用一个队列来存储打印结果，每次从队列头部插入。
+
+## 代码
+
+```js
+/*function ListNode(x){
+    this.val = x;
+    this.next = null;
+}*/
+function printListFromTailToHead(head)
+{
+    const array = [];
+    while(head){
+        array.unshift(head.val);
+        head = head.next;
+    }
+    return array;
+}
+```
+
+## 考察点
+
+- 链表

docs/dataStructure/链表/删除链表中的节点or重复的节点.md

@@ -0,0 +1,126 @@
+---
+{
+  "title": "删除链表中的节点or重复的节点",
+}
+---
+
+## 删除链表中的节点
+
+给定单链表的头指针和要删除的指针节点，在O(1)时间内删除该节点。
+
+- 1.删除的节点不是尾部节点 - 将next节点覆盖当前节点
+- 2.删除的节点是尾部节点且等于头节点，只剩一个节点 - 将头节点置为null
+- 3.删除的节点是尾节点且前面还有节点 - 遍历到末尾的前一个节点删除
+
+只有第三种情况时间复杂度是O(n)，且这种情况只会出现1/n次，所以算法时间复杂度是O(1)
+```js
+    var deleteNode = function (head, node) {
+      if (node.next) {
+        node.val = node.next.val;
+        node.next = node.next.next;
+      } else if (node === head) {
+        node = null;
+        head = null;
+      } else {
+        node = head;
+        while (node.next.next) {
+          node = node.next;
+        }
+        node.next = null;
+        node = null;
+      }
+      return node;
+    };
+```
+
+## 删除链表中重复的节点
+
+### 方法1.存储链表中元素出现的次数
+
+- 1.用一个map存储每个节点出现的次数
+- 2.删除出现次数大于1的节点
+
+此方法删除节点时可以使用上面总结的办法。
+
+时间复杂度：O(n) 
+
+空间复杂度：O(n)
+
+```js
+    function deleteDuplication(pHead) {
+      const map = {};
+      if (pHead && pHead.next) {
+        let current = pHead;
+        // 计数
+        while (current) {
+          const val = map[current.val];
+          map[current.val] = val ? val + 1 : 1;
+          current = current.next;
+        }
+        current = pHead;
+        while (current) {
+          const val = map[current.val];
+          if (val > 1) {
+            // 删除节点
+            console.log(val);
+            if (current.next) {
+              current.val = current.next.val;
+              current.next = current.next.next;
+            } else if (current === pHead) {
+              current = null;
+              pHead = null;
+            } else {
+              current = pHead;
+              while (current.next.next) {
+                current = current.next;
+              }
+              current.next = null;
+              current = null;
+            }
+
+          } else {
+            current = current.next;
+          }
+        }
+      }
+      return pHead;
+    }
+```
+
+
+### 方法2.重新比较连接数组
+
+
+链表是排好顺序的，所以重复元素都会相邻出现
+       递归链表：
+- 1.当前节点或当前节点的next为空，返回该节点
+- 2.当前节点是重复节点：找到后面第一个不重复的节点
+- 3.当前节点不重复：将当前的节点的next赋值为下一个不重复的节点
+
+```js
+    function deleteDuplication(pHead) {
+      if (!pHead || !pHead.next) {
+        return pHead;
+      } else if (pHead.val === pHead.next.val) {
+        let tempNode = pHead.next;
+        while (tempNode && pHead.val === tempNode.val) {
+          tempNode = tempNode.next;
+        }
+        return deleteDuplication(tempNode);
+      } else {
+        pHead.next = deleteDuplication(pHead.next);
+        return pHead;
+      }
+    }
+```
+
+
+时间复杂度：O(n) 
+
+空间复杂度：O(1)
+
+
+## 考察点
+
+- 链表
+- 考虑问题的全面性

docs/dataStructure/链表/反转链表.md

@@ -0,0 +1,33 @@
+---
+{
+  "title": "反转链表",
+}
+---
+
+## 反转链表
+
+输入一个链表，反转链表后，输出新链表的表头。
+
+## 思路
+
+以链表的头部节点为基准节点
+
+将基准节点的下一个节点挪到头部作为头节点
+
+当基准节点的`next`为`null`，则其已经成为最后一个节点，链表已经反转完成
+
+## 代码
+
+```js
+    var reverseList = function (head) {
+      let currentNode = null;
+      let headNode = head;
+      while (head && head.next) {
+        currentNode = head.next;
+        head.next = currentNode.next;
+        currentNode.next = headNode;
+        headNode = currentNode;
+      }
+      return headNode;
+    };
+```

docs/dataStructure/链表/合并两个排序的链表.md

@@ -0,0 +1,45 @@
+---
+{
+  "title": "合并两个排序的链表",
+}
+---
+## 题目
+
+输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
+
+## 思路
+
+![image](../../dist/img/合并链表.png)
+
+链表头部节点比较，取较小节点。
+
+小节点的next等于小节点的next和大节点的较小值。
+
+如此递归。
+
+返回小节点。
+
+考虑代码的鲁棒性，也是递归的终止条件，两个head为null的情况，取对方节点返回。
+
+## 代码
+
+```js
+    function Merge(pHead1, pHead2) {
+      if (!pHead1) {
+        return pHead2;
+      }
+      if (!pHead2) {
+        return pHead1;
+      }
+      let head;
+      if (pHead1.val < pHead2.val) {
+        head = pHead1;
+        head.next = Merge(pHead1.next, pHead2);
+      } else {
+        head = pHead2;
+        head.next = Merge(pHead1, pHead2.next);
+      }
+      return head;
+    }
+```
+