[Function add]

1. Add leetcode solutions.
2. Add conclusion about quick sort.

Author: Botao Xiao

DataStructrue/Sort/QuickSort.md

@@ -0,0 +1,40 @@
+## QuickSort 快速排序
+快速排序较为稳定，时间复杂度为O(NLogN)。
+
+### 实现逻辑
+1. 找到一个pivot(基准点)，用来比较大小。
+2. 从左向右遍历，找到第一个大于pivot的元素。
+3. 从右向左遍历，找到第一个小于pivot的元素。
+4. 交换2和3中找到的两个元素。
+4. 交换pivot和index的位置，保证左边的数都小于pivot,右边的数都大于pivot。
+
+### 实现代码
+```Java
+public void sortColors(int[] nums) {
+    if(null == nums) return;
+    quickSort(nums, 0, nums.length - 1);
+}
+private void quickSort(int[] nums, int low, int high){
+    if(low > high) return;
+    int i = partition(nums, low, high);
+    quickSort(nums, low, i - 1);  //递归调用
+    quickSort(nums, i + 1, high);
+}
+private int partition(int[] nums, int low, int high){
+    int i = low, j = high + 1;
+    int cmp = nums[low];
+    while(true){
+        while(nums[++i] <= cmp) if(i == high) break;  //找到第一个大于pivot的元素
+        while(nums[--j] > cmp) if(j == low) break;  //找到第一个小于pivot的元素
+        if(i >= j) break;
+        swap(nums, i, j); //交换这两个数字的位置。
+    }
+    swap(nums, low, j); //将pivot和index换位置，此时左边的的所有数都小于pivot，右边的数都大于pivot。
+    return j; //返回当前的index位置。
+}
+private static void swap(int[] nums, int i, int j){
+    int temp = nums[i];
+    nums[i] = nums[j];
+    nums[j] = temp;
+}
+```

README.md

@@ -141,15 +141,12 @@
 
 [71. Simplify Path](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/71.%20Simplify%20Path.md)
 
-<<<<<<< HEAD
 [72. Edit Distance](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/72.%20Edit%20Distance.md)
 
 [73. Set Matrix Zeroes](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/73.%20Set%20Matrix%20Zeroes.md)
 
 [74. Search a 2D Matrix](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/74.%20Search%20a%202D%20Matrix.md)
 
-=======
->>>>>>> 5ddac4c8fb078caea256a647f91903353b2ab074
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.
@@ -158,7 +155,7 @@ All java realization codes are placed in different packages.
 * [Insertion](https://github.com/Seanforfun/Algorithm/blob/master/DataStructrue/Sort/InsertionSort.md)
 * [Shell]()
 * [Merge](https://github.com/Seanforfun/Algorithm/blob/master/DataStructrue/Sort/MergeSort.md)
-* [QuickSort]()
+* [QuickSort](https://github.com/Seanforfun/Algorithm/blob/master/DataStructrue/Sort/QuickSort.md)
 * [Priority Queue]()
 * [BucketSort](https://github.com/Seanforfun/Algorithm/blob/master/DataStructrue/Sort/BucketSort.md)
 

leetcode/69. Sqrt(x).md

@@ -65,8 +65,4 @@ class Solution {
         }
     }
 }
-<<<<<<< HEAD
 ```
-=======
-```
->>>>>>> 5ddac4c8fb078caea256a647f91903353b2ab074

leetcode/70. Climbing Stairs.md

@@ -81,8 +81,3 @@ class Solution {
         return dp[n];
     }
 }
-<<<<<<< HEAD
-```
-=======
-```
->>>>>>> 5ddac4c8fb078caea256a647f91903353b2ab074

leetcode/71. Simplify Path.md

@@ -1,26 +1,18 @@
 ## 71. Simplify Path
 
 ### Question
-<<<<<<< HEAD
 Given an absolute path for a file (Unix-style), simplify it.
 
 ```
-=======
-Given an absolute path for a file (Unix-style), simplify it. 
-
->>>>>>> 5ddac4c8fb078caea256a647f91903353b2ab074
 For example,
 path = "/home/", => "/home"
 path = "/a/./b/../../c/", => "/c"
 path = "/a/../../b/../c//.//", => "/c"
 path = "/a//b////c/d//././/..", => "/a/b/c"
 
 In a UNIX-style file system, a period ('.') refers to the current directory, so it can be ignored in a simplified path. Additionally, a double period ("..") moves up a directory, so it cancels out whatever the last directory was. For more information, look here: https://en.wikipedia.org/wiki/Path_(computing)#Unix_style
-<<<<<<< HEAD
 ```
-=======
 
->>>>>>> 5ddac4c8fb078caea256a647f91903353b2ab074
 Corner Cases:
 * Did you consider the case where path = "/../"?
 * In this case, you should return "/".
@@ -55,8 +47,4 @@ class Solution {
         return sb.toString();
     }
 }
-<<<<<<< HEAD
-```
-=======
 ```
->>>>>>> 5ddac4c8fb078caea256a647f91903353b2ab074

leetcode/75. Sort Colors.md

@@ -1,4 +1,25 @@
 ## 75. Sort Colors
+
+### Question
+Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white and blue.
+
+Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.
+
+Note: You are not suppose to use the library's sort function for this problem.
+
+```
+Example:
+
+Input: [2,0,2,1,1,0]
+Output: [0,0,1,1,2,2]
+```
+
+Follow up:
+* A rather straight forward solution is a two-pass algorithm using counting sort.
+* First, iterate the array counting number of 0's, 1's, and 2's, then overwrite array with total number of 0's, then 1's and followed by 2's.
+* Could you come up with a one-pass algorithm using only constant space?
+
+
 ### Thinking:
 * Method1:
 	* 排序算法
@@ -34,4 +55,55 @@ class Solution {
         nums[high] = temp;
     }
 }
-```
+```
+
+### 二刷, 借助二刷的机会，尽量复习多种排序方法。
+1. 冒泡法
+```Java
+public void sortColors(int[] nums) {
+		int len = nums.length;
+		for(int i = 0; i < len - 1; i++){
+				for(int j = i + 1; j < len; j++){
+					//如果遍历到的位置的值小于外部遍历的值，就交换两个值
+						if(nums[j] < nums[i]){
+								int temp = nums[i];
+								nums[i] = nums[j];
+								nums[j] = temp;
+						}
+				}
+		}
+}
+```
+
+2. 快速排序
+```Java
+class Solution {
+    public void sortColors(int[] nums) {
+        if(null == nums) return;
+        quickSort(nums, 0, nums.length - 1);
+    }
+    private void quickSort(int[] nums, int low, int high){
+        if(low > high) return;
+        int i = partition(nums, low, high);
+        quickSort(nums, low, i - 1);
+        quickSort(nums, i + 1, high);
+    }
+    private int partition(int[] nums, int low, int high){
+        int i = low, j = high + 1;
+        int cmp = nums[low];
+        while(true){
+            while(nums[++i] <= cmp) if(i == high) break;
+            while(nums[--j] > cmp) if(j == low) break;
+            if(i >= j) break;
+            swap(nums, i, j);
+        }
+        swap(nums, low, j);
+        return j;
+    }
+    private static void swap(int[] nums, int i, int j){
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
+}
+```