🎨 update: array

Author: ConardLi

docs/.vuepress/config.js

@@ -35,14 +35,6 @@ module.exports = {
                         '/dataStructure/二叉树/树的子结构',
                     ]
                 },
-                {
-                    title: '堆',
-                    children: [
-                        '/dataStructure/堆/堆的基本操作',
-                        '/dataStructure/堆/数据流中的中位数',
-                        '/dataStructure/堆/最小的k个数',
-                    ]
-                },
                 {
                     title: '链表',
                     children: [
@@ -57,6 +49,34 @@ module.exports = {
                         '/dataStructure/链表/删除链表中的节点or重复的节点',
                     ]
                 },
+                {
+                    title: '数组',
+                    children: [
+                        '/dataStructure/数组/把数组排成最小的数',
+                        '/dataStructure/数组/第一个只出现一次的字符',
+                        '/dataStructure/数组/调整数组顺序使奇数位于偶数前面',
+                        '/dataStructure/数组/构建乘积数组',
+                        '/dataStructure/数组/和为S的连续正整数序列',
+                        '/dataStructure/数组/和为S的两个数字',
+                        '/dataStructure/数组/连续子数组的最大和',
+                        '/dataStructure/数组/两数之和',
+                        '/dataStructure/数组/扑克牌顺子',
+                        '/dataStructure/数组/三数之和',
+                        '/dataStructure/数组/数组中出现次数超过数组长度一半的数字',
+                        '/dataStructure/数组/数组中的逆序对',
+                        '/dataStructure/数组/顺时针打印矩阵',
+                        '/dataStructure/数组/四数之和',
+                        '/dataStructure/数组/在排序数组中查找数字',
+                    ]
+                },
+                {
+                    title: '堆',
+                    children: [
+                        '/dataStructure/堆/堆的基本操作',
+                        '/dataStructure/堆/数据流中的中位数',
+                        '/dataStructure/堆/最小的k个数',
+                    ]
+                },
             ]
         }
     }

docs/dataStructure/数组/三数之和.md

@@ -0,0 +1,69 @@
+---
+{
+  "title": "三数之和",
+}
+---
+
+## 题目
+
+给定一个包含 `n` 个整数的数组` nums`，判断 `nums` 中是否存在三个元素` a，b，c` ，使得 `a + b + c = 0 ？`找出所有满足条件且不重复的三元组。
+
+注意：答案中不可以包含重复的三元组。
+
+```js
+例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，
+
+满足要求的三元组集合为：
+[
+  [-1, 0, 1],
+  [-1, -1, 2]
+]
+```
+
+## 思路
+
+题目中说明可能会出现多组结果，所以我们要考虑好去重
+
+- 1.为了方便去重，我们首先将数组排序
+- 2.对数组进行遍历，取当前遍历的数`nums[i]`为一个基准数，遍历数后面的数组为寻找数组
+- 3.在寻找数组中设定两个起点，最左侧的`left`(`i+1`)和最右侧的`right`(`length-1`)
+- 4.判断`nums[i] + nums[left] + nums[right]`是否等于0，如果等于0，加入结果，并分别将`left`和`right`移动一位
+- 5.如果结果大于0，将`right`向左移动一位，向结果逼近
+- 5.如果结果小于0，将`left`向右移动一位，向结果逼近
+
+注意整个过程中要考虑去重
+
+## 代码
+
+
+```js
+    var threeSum = function (nums) {
+      const result = [];
+      nums.sort((a, b) => a - b);
+      for (let i = 0; i < nums.length; i++) {
+        // 跳过重复数字
+        if (i && nums[i] === nums[i - 1]) { continue; }
+        let left = i + 1;
+        let right = nums.length - 1;
+        while (left < right) {
+          const sum = nums[i] + nums[left] + nums[right];
+          if (sum > 0) {
+            right--;
+          } else if (sum < 0) {
+            left++;
+          } else {
+            result.push([nums[i], nums[left++], nums[right--]]);
+            // 跳过重复数字
+            while (nums[left] === nums[left - 1]) {
+              left++;
+            }
+            // 跳过重复数字
+            while (nums[right] === nums[right + 1]) {
+              right--;
+            }
+          }
+        }
+      }
+      return result;
+    }
+```

docs/dataStructure/数组/两数之和.md

@@ -0,0 +1,53 @@
+---
+{
+  "title": "两数之和",
+}
+---
+
+## 题目
+
+
+给定一个整数数组 `nums` 和一个目标值 `target`，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。
+
+你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
+
+示例:
+
+```js
+给定 nums = [2, 7, 11, 15], target = 9
+
+因为 nums[0] + nums[1] = 2 + 7 = 9
+所以返回 [0, 1]
+```
+
+## 思路
+
+使用一个`map`将遍历过的数字存起来，值作为`key`，下标作为值。
+
+对于每一次遍历：
+
+- 取`map`中查找是否有`key`为`target-nums[i]`的值
+- 如果取到了，则条件成立，返回。
+- 如果没有取到，将当前值作为`key`，下标作为值存入`map`
+
+时间复杂度：`O(n)`
+
+空间复杂度`O(n)`
+
+## 代码
+
+```js
+    var twoSum = function (nums, target) {
+      const map = {};
+      if (Array.isArray(nums)) {
+        for (let i = 0; i < nums.length; i++) {
+          if (map[target - nums[i]] != undefined) {
+            return [map[target - nums[i]], i];
+          } else {
+            map[nums[i]] = i;
+          }
+        }
+      }
+      return [];
+    };
+```

docs/dataStructure/数组/和为S的两个数字.md

@@ -0,0 +1,49 @@
+---
+{
+  "title": "和为S的两个数字",
+}
+---
+
+## 题目
+
+输入一个递增排序的数组和一个数字`S`，在数组中查找两个数，使得他们的和正好是`S`，如果有多对数字的和等于`S`，输出两个数的乘积最小的。
+
+## 思路
+
+> 数组中可能有多对符合条件的结果，而且要求输出乘积最小的，说明要分布在两侧 比如 `3,8 ` `5,7`  要取`3,8`。
+
+看了题目了，很像`leetcode`的第一题【两数之和】，但是题目中有一个明显不同的条件就是数组是有序的，可以使用使用大小指针求解，不断逼近结果，最后取得最终值。
+
+- 设定一个小索引`left`，从`0`开始
+- 设定一个大索引`right`，从`array.length`开始
+- 判断`array[left] + array[right]`的值`s`是否符合条件
+- 符合条件 - 返回
+- 大于`sum`，`right`向左移动
+- 小于`sum`，`left`向右移动
+- 若`left=right`，没有符合条件的结果 
+
+> 类似【两数之和】的解法来求解，使用`map`存储另已经遍历过的`key`，这种解法在有多个结果的情况下是有问题的，因为这样优先取得的结果是乘积较大的。例如 `3,8 ` `5,7` ，会优先取到`5,7`。
+
+
+## 代码
+
+```js
+    function FindNumbersWithSum(array, sum) {
+      if (array && array.length > 0) {
+        let left = 0;
+        let right = array.length - 1;
+        while (left < right) {
+          const s = array[left] + array[right];
+          if (s > sum) {
+            right--;
+          } else if (s < sum) {
+            left++;
+          } else {
+            return [array[left], array[right]]
+          }
+        }
+      }
+      return [];
+    }
+```
+

docs/dataStructure/数组/和为S的连续正整数序列.md

@@ -0,0 +1,50 @@
+---
+{
+  "title": "和为S的连续正整数序列",
+}
+---
+
+## 题目
+
+输入一个正数`S`，打印出所有和为S的连续正数序列。
+
+例如：输入`15`，有序`1+2+3+4+5` = `4+5+6` = `7+8` = `15` 所以打印出3个连续序列`1-5`，`5-6`和`7-8`。
+
+## 思路
+
+- 创建一个容器`child`，用于表示当前的子序列，初始元素为`1,2`
+
+- 记录子序列的开头元素`small`和末尾元素`big`
+
+- `big`向右移动子序列末尾增加一个数 `small`向右移动子序列开头减少一个数
+
+- 当子序列的和大于目标值，`small`向右移动，子序列的和小于目标值，`big`向右移动
+
+## 代码
+
+```js
+    function FindContinuousSequence(sum) {
+      const result = [];
+      const child = [1, 2];
+      let big = 2;
+      let small = 1;
+      let currentSum = 3;
+      while (big < sum) {
+        while (currentSum < sum && big < sum) {
+          child.push(++big);
+          currentSum += big;
+        }
+        while (currentSum > sum && small < big) {
+          child.shift();
+          currentSum -= small++;
+        }
+        if (currentSum === sum && child.length > 1) {
+          result.push(child.slice());
+          child.push(++big);
+          currentSum += big;
+        }
+      }
+      return result;
+    }
+```
+

docs/dataStructure/数组/四数之和.md

@@ -0,0 +1,73 @@
+---
+{
+  "title": "四数之和",
+}
+---
+
+## 题目
+
+给定一个包含 `n` 个整数的数组` nums`，判断 `nums` 中是否存在四个元素` a，b，c，d` ，使得 `a + b + c + d = 0 ？`找出所有满足条件且不重复的四元组。
+
+注意：答案中不可以包含重复的四元组。
+
+
+```js
+给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
+
+满足要求的四元组集合为：
+[
+  [-1,  0, 0, 1],
+  [-2, -1, 1, 2],
+  [-2,  0, 0, 2]
+]
+```
+
+## 思路
+
+你已经经历了两数之和、三数之和，玩玩没想到，还有四数之和...
+
+其实，后面还有五数之和，六数之和...
+
+到这里其实我们就能发现一些规律，我们可以像[三数之和](https://github.com/ConardLi/awesome-coding-js/blob/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%88%86%E7%B1%BB/%E6%95%B0%E7%BB%84/%E4%B8%89%E6%95%B0%E4%B9%8B%E5%92%8C.md)那样，我们可以通过大小指针来逼近结果，从而达到降低一层时间复杂度的效果。
+
+不管是几数之和，我们都用这种方法来进行优化。
+
+## 代码
+
+
+```js
+var fourSum = function (nums, target) {
+    if (nums.length < 4) {
+        return [];
+    }
+    nums.sort((a, b) => a - b);
+    const result = [];
+    for (let i = 0; i < nums.length - 3; i++) {
+        if (i > 0 && nums[i] === nums[i - 1]) {
+            continue;
+        }
+        if (nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) {
+            break;
+        }
+        for (let j = i + 1; j < nums.length - 2; j++) {
+            if (j > i + 1 && nums[j] === nums[j - 1]) {
+                continue;
+            }
+            let left = j + 1,
+                right = nums.length - 1;
+            while (left < right) {
+                const sum = nums[i] + nums[j] + nums[left] + nums[right];
+                if (sum === target) {
+                    result.push([nums[i], nums[j], nums[left], nums[right]]);
+                }
+                if (sum <= target) {
+                    while (nums[left] === nums[++left]);
+                } else {
+                    while (nums[right] === nums[--right]);
+                }
+            }
+        }
+    }
+    return result;
+};
+```