feat: #912

README.en.md

@@ -158,7 +158,7 @@ The data structures mainly includes:
 - [0046.permutations](./problems/46.permutations.md)
 - [0047.permutations-ii](./problems/47.permutations-ii.md)
 - [0048.rotate-image](./problems/48.rotate-image.md)
-- [0049.group-anagrams](./problems/49.group-anagrams.md) 
+- [0049.group-anagrams](./problems/49.group-anagrams.md)
 - [0055.jump-game](./problems/55.jump-game.md)
 - [0056.merge-intervals](./problems/56.merge-intervals.md)
 - [0062.unique-paths](./problems/62.unique-paths.md )
@@ -171,36 +171,36 @@ The data structures mainly includes:
 - [0091.decode-ways](./problems/91.decode-ways.md)
 - [0092.reverse-linked-list-ii](./problems/92.reverse-linked-list-ii.md)
 - [0094.binary-tree-inorder-traversal](./problems/94.binary-tree-inorder-traversal.md)
-- [0098.validate-binary-search-tree](./problems/98.validate-binary-search-tree.md) 🆕 
+- [0098.validate-binary-search-tree](./problems/98.validate-binary-search-tree.md) 🆕
 - [0102.binary-tree-level-order-traversal](./problems/102.binary-tree-level-order-traversal.md)
 - [0103.binary-tree-zigzag-level-order-traversal](./problems/103.binary-tree-zigzag-level-order-traversal.md)
 - [0113.path-sum-ii](./problems/113.path-sum-ii.md)
 - [0129.sum-root-to-leaf-numbers](./problems/129.sum-root-to-leaf-numbers.md) 🆕
-- [0130.surrounded-regions](./problems/130.surrounded-regions.md) 🆕 
+- [0130.surrounded-regions](./problems/130.surrounded-regions.md) 🆕
 - [0131.palindrome-partitioning](./problems/131.palindrome-partitioning.md)
 - [0139.word-break](./problems/139.word-break.md)
 - [0144.binary-tree-preorder-traversal](./problems/144.binary-tree-preorder-traversal.md)
 - [0150.evaluate-reverse-polish-notation](./problems/150.evaluate-reverse-polish-notation.md)
 - [0152.maximum-product-subarray](./problems/152.maximum-product-subarray.md)
 - [0199.binary-tree-right-side-view](./problems/199.binary-tree-right-side-view.md)
-- [0200.number-of-islands](./problems/200.number-of-islands.md) 🆕 
+- [0200.number-of-islands](./problems/200.number-of-islands.md) 🆕
 - [0201.bitwise-and-of-numbers-range](./problems/201.bitwise-and-of-numbers-range.md)
 - [0208.implement-trie-prefix-tree](./problems/208.implement-trie-prefix-tree.md)
 - [0209.minimum-size-subarray-sum](./problems/209.minimum-size-subarray-sum.md)
-- [0215.kth-largest-element-in-an-array](./problems/215.kth-largest-element-in-an-array.md) 🆕 
-- [0221.maximal-square](./problems/221.maximal-square.md) 🆕 
-- [0229.majority-element-ii](./problems/229.majority-element-ii.md) 🆕 
+- [0215.kth-largest-element-in-an-array](./problems/215.kth-largest-element-in-an-array.md) 🆕
+- [0221.maximal-square](./problems/221.maximal-square.md) 🆕
+- [0229.majority-element-ii](./problems/229.majority-element-ii.md) 🆕
 - [0230.kth-smallest-element-in-a-bst](./problems/230.kth-smallest-element-in-a-bst.md)
-- [0236.lowest-common-ancestor-of-a-binary-tree](./problems/236.lowest-common-ancestor-of-a-binary-tree.md)🆕 
+- [0236.lowest-common-ancestor-of-a-binary-tree](./problems/236.lowest-common-ancestor-of-a-binary-tree.md)🆕
 - [0238.product-of-array-except-self](./problems/238.product-of-array-except-self.md)
 - [0240.search-a-2-d-matrix-ii](./problems/240.search-a-2-d-matrix-ii.md)
 - [0279.perfect-squares](./problems/279.perfect-squares.md)
-- [0309.best-time-to-buy-and-sell-stock-with-cooldown](./problems/309.best-time-to-buy-and-sell-stock-with-cooldown.md) 🆕 
+- [0309.best-time-to-buy-and-sell-stock-with-cooldown](./problems/309.best-time-to-buy-and-sell-stock-with-cooldown.md) 🆕
 - [0322.coin-change](./problems/322.coin-change.md)
 - [0328.odd-even-linked-list](./problems/328.odd-even-linked-list.md)
 - [0334.increasing-triplet-subsequence](./problems/334.increasing-triplet-subsequence.md)
 - [0365.water-and-jug-problem](./problems/365.water-and-jug-problem.md)
-- [0378.kth-smallest-element-in-a-sorted-matrix](./problems/378.kth-smallest-element-in-a-sorted-matrix.md) 🆕 
+- [0378.kth-smallest-element-in-a-sorted-matrix](./problems/378.kth-smallest-element-in-a-sorted-matrix.md) 🆕
 - [0416.partition-equal-subset-sum](./problems/416.partition-equal-subset-sum.md)
 - [0445.add-two-numbers-ii](./problems/445.add-two-numbers-ii.md)
 - [0454.4-sum-ii](./problems/454.4-sum-ii.md)
@@ -214,6 +214,7 @@ The data structures mainly includes:
 - [0877.stone-game](./problems/877.stone-game.md)
 - [0887.super-egg-drop](./problems/887.super-egg-drop.md)
 - [0900.rle-iterator](./problems/900.rle-iterator.md)
+- [0912.sort-an-array](./problems/912.sort-an-array.md) 🆕
 - [1031.maximum-sum-of-two-non-overlapping-subarrays](./problems/1031.maximum-sum-of-two-non-overlapping-subarrays.md) 🆕
 
 #### Hard

README.md

@@ -225,6 +225,7 @@ leetcode 题解，记录自己的 leetcode 解题之路。
 - [0877.stone-game](./problems/877.stone-game.md)
 - [0887.super-egg-drop](./problems/887.super-egg-drop.md)
 - [0900.rle-iterator](./problems/900.rle-iterator.md)
+- [0912.sort-an-array](./problems/912.sort-an-array.md) 🆕
 - [1031.maximum-sum-of-two-non-overlapping-subarrays](./problems/1031.maximum-sum-of-two-non-overlapping-subarrays.md) 🆕
 
 #### 困难难度

assets/drawio/912.sort-an-array.drawio

@@ -0,0 +1 @@
+<mxfile modified="2019-09-14T09:21:59.588Z" host="www.draw.io" agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36" etag="pFvn7xNMapLTBJD5jPEq" version="11.2.8" type="device" pages="1"><diagram id="tFO1_1GZ6p5RLwFWiUon" name="第 1 页">7Zxdb6M4FIZ/TS4Tgc1HuEyyzaxWWmlHlWZ2584b3AQNwalxmmR+/ZhgoHBIp2FIcCX3og3HcBz8vLY5x6YjvNgeP3Gy2/zNQhqPkBUeR/iPEUIBtuXvzHDKDY7n54Y1j8LcZFeGx+gHVUZLWfdRSNPaiYKxWES7unHFkoSuRM1GOGeH+mlPLK7XuiNrCgyPKxJD69coFJvcOkV+Zf+TRutNUbPtBXnJlhQnqztJNyRkh1cm/DDCC86YyD9tjwsaZ21XtEt+3fJCafnFOE3Eey6YfVvG/y7/+0K+zl9Ou2/T57+eP4+VlxcS79UNu+rbilPRBJztk5BmXuwRnh82kaCPO7LKSg+SubRtxDZWxU8sEYqi7anjBYsZP/vCy+XUsixpj8n/NJ4zHlJeFCcskZfN1zFJM2jZWUzWE4lMOtPsMBWcfS85oNLyqoLg/CNL1I1RLujxYovZJQepX8q2VPCTPEVdgKZefonSrqdIHiohuMq0eaWBwkaU9Nal44qO/KAAXQELAVi2gVXAwlgvWNjAegOWZj3LAbCQgVXAcjTrWS6AZRlYJSzNepZnYF2G5WrWs4K7wwqCxeKjwHJrrMoIZShYRf2GVhst29INFwy1DK4Kl3a9CwZbt34k/EC4mpHx8LhguGVwXYyNh8cFA65bR8cfCZd2vQuGXJPJBACTdyzqVOrNpBr6KYrjhonE0TqRhyvZQlTa51n7RSsSz1TBNgrDrJpWGVRCsRocX6kCW2+oosG7jxGymO9Lhi5g6LQwRDdj6AOGI+TFGbB0R5IaSe95n2Wlz801Ts/tN5Mn2N7uWBXKT+vs79i1sohL+ZLfLXeXFxqNXBFRBLCb31ci01tJxDkPjkYi1z8XF0O/LhpBMOrsUSNTo5EOGvF00wgMdfvRiJll+ojVBpcHDK37kYdt5NEh2HBszeQBQ/l+5IGMPDrII9BNHjB10I88sJFHh+VG7UYPmKroRx6OkUcHeQS6PXvA9eh+5OEaeXRIgDi6yQMmycwi3cWNQIPnpRFMWBlcF7cCDY8L7i8xqz4XNwMNjgvDVJ9Z9XmboQd2nUyHndAwzLWYEbLC5TmadTmY+zC4Sly+rRsumIswuCpc2vWum+UGzNJVTwPw0AEgvlV+wKyAdx70A80kcquNNGYfTeeJRjeJwEAXAKRJOMveT85IZK0YrS4+CbQ3p3rPpT6p47ZJfbmcu37V1jQErzz/sqXfOWVzGhMRvdTdtzWvquEfFsmKq8Umqx4C4ymuu0jZnq+ouqqC9GtHqOFIEL6mAjg60y5v+zfeJ2zbJaOBAEKSbspHUe3V0NjX0l0NTUf3VkPbfhijhuvU4NjWxG3owemmhxZXyLmvImBaxijiakV4Tm+KgK7urYi2XS9GEdcpwrV7en4Aju49Y7RtcjFquFINfk/PD8DRvdUA81aRDMKOQBJaB4WoRYT+w8x7aMlUjn4/KGy+W6F61FAhoQMTSyvZasIwfD9DNPArVA7M/CT7bWoQvrX7HNXHTn9ohnDLSGCjScq4GJNkTDgnp0tAdaLo3JeiW6foYJhhw1YAOfrXc5SH1T/Fy6fQ6j8L4oef</diagram></mxfile>

problems/912.sort-an-array.md

@@ -0,0 +1,154 @@
+
+## 题目地址
+https://leetcode.com/problems/sort-an-array/
+
+## 题目描述
+```
+Given an array of integers nums, sort the array in ascending order.
+
+
+
+Example 1:
+
+Input: [5,2,3,1]
+Output: [1,2,3,5]
+Example 2:
+
+Input: [5,1,1,2,0,0]
+Output: [0,0,1,1,2,5]
+
+
+Note:
+
+1 <= A.length <= 10000
+-50000 <= A[i] <= 50000
+```
+
+## 思路
+
+这是一个很少见的直接考察`排序`的题目。 其他题目一般都是暗含`排序`，这道题则简单粗暴，直接让你排序。
+并且这道题目的难度是`Medium`， 笔者感觉有点不可思议。
+
+我们先来看题目的限制条件，这其实在选择算法的过程中是重要的。 看到这道题的时候，大脑就闪现出了各种排序算法，
+这也算是一个复习`排序算法`的机会吧。
+
+题目的限制条件是有两个，第一是元素个数不超过10k，这个不算大。 另外一个是数组中的每一项范围都是`-50k`到`50k`（包含左右区间）。
+看到这里，基本我就排除了时间复杂度为O(n^2)的算法。
+
+> 我没有试时间复杂度 O(n^2) 的解法，大家可以试一下，看是不是会TLE。
+
+剩下的就是基于比较的`nlogn`算法，以及基于特定条件的O(n)算法。
+
+由于平时很少用到`计数排序`等O(n)的排序算法，一方面是空间复杂度不是常量，另一方面是其要求数据范围不是很大才行，不然会浪费很多空间。
+但是这道题我感觉可以试一下。  在这里，我用了两种方法，一种是`计数排序`，一种是`快速排序`来解决。 大家也可以尝试用别的解法来解决。
+
+### 解法一 - 计数排序
+
+时间复杂度O(n)空间复杂度O(m) m 为数组中值的取值范围，在这道题就是`50000 * 2 + 1`。
+
+我们只需要准备一个数组取值范围的数字，然后遍历一遍，将每一个元素放到这个数组对应位置就好了，
+放的规则是`索引为数字的值，value为出现的次数`。
+
+这样一次遍历，我们统计出了所有的数字出现的位置和次数。 我们再来一次遍历，将其输出到即可。
+
+![sort-an-array-1](../assets/problems/912.sort-an-array-1.png)
+
+
+### 解法二 - 快速排序
+
+快速排序和归并排序都是分支思想来进行排序的算法， 并且二者都非常流行。 快速排序的核心点在于选择轴元素。
+
+每次我们将数组分成两部分，一部分是比pivot（轴元素）大的，另一部分是不比pivot大的。 我们不断重复这个过程，
+直到问题的规模缩小的寻常（即只有一个元素的情况）。
+
+快排的核心点在于如何选择轴元素，一般而言，选择轴元素有三种策略：
+
+- 数组最左边的元素
+- 数组最右边的元素
+- 数组中间的元素（我采用的是这种，大家可以尝试下别的）
+- 数组随机一项元素
+
+
+![sort-an-array-2](../assets/problems/912.sort-an-array-2.png)
+
+(图片来自： https://www.geeksforgeeks.org/quick-sort/)
+
+> 图片中的轴元素是最后面的元素，而提供的解法是中间元素，这点需要注意，但是这并不影响理解。
+
+
+## 关键点解析
+
+- 排序算法
+- 注意题目的限制条件从而选择合适的算法
+
+
+## 代码
+
+计数排序：
+
+代码支持： JavaScript
+```js
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var sortArray = function(nums) {
+    const counts = Array(50000 * 2 + 1).fill(0);
+    const res = [];
+    for(const num of nums) counts[50000 + num] += 1;
+    for(let i in counts)  {
+        while(counts[i]--) {
+            res.push(i - 50000)
+        }
+    }
+    return res;
+};
+```
+
+
+快速排序：
+
+代码支持： JavaScript
+```js
+function swap(nums, a, b) {
+    const temp = nums[a];
+    nums[a] = nums[b];
+    nums[b] = temp;
+}
+
+function helper(nums, start, end) {
+    if (start >= end) return;
+    const pivotIndex = start + ((end - start) >>> 1)
+    const pivot = nums[pivotIndex]
+    let i = start;
+    let j = end;
+    while (i <= j) {
+        while (nums[i] < pivot) i++;
+        while (nums[j] > pivot) j--;
+        if (i <= j) {
+            swap(nums, i, j);
+            i++;
+            j--;
+        }
+    }
+    helper(nums, start, j);
+    helper(nums, i, end);
+}
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var sortArray = function(nums) {
+    helper(nums, 0, nums.length - 1);
+    return nums;
+};
+```
+
+## 扩展
+
+- 你是否可以用其他方式排序算法解决
+
+## 参考
+
+- [QuickSort - geeksforgeeks](https://www.geeksforgeeks.org/quick-sort/)