From 34d60325b37e4eb87b767ad7335cb68667d0e6d1 Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Tue, 10 Jul 2018 16:39:00 +0800
Subject: [PATCH 01/18] git test

---
 test.cpp | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 test.cpp

diff --git a/test.cpp b/test.cpp
new file mode 100644
index 0000000..a189e73
--- /dev/null
+++ b/test.cpp
@@ -0,0 +1 @@
+121212121212121212121212121212121212121212121212

From e1d354106f7572c16adab37dd87f1a6ae75bf698 Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Tue, 10 Jul 2018 16:40:14 +0800
Subject: [PATCH 02/18] add something

---
 test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test.cpp b/test.cpp
index a189e73..a8e5999 100644
--- a/test.cpp
+++ b/test.cpp
@@ -1 +1 @@
-121212121212121212121212121212121212121212121212
+121212121212121212121212121212121212121212121212dsfsdf

From b658b780b7fab6b49e51c31b66030b11426874a5 Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Tue, 10 Jul 2018 17:01:31 +0800
Subject: [PATCH 03/18] shell add

---
 shell_Sort.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/shell_Sort.cpp b/shell_Sort.cpp
index 50070e5..288894b 100644
--- a/shell_Sort.cpp
+++ b/shell_Sort.cpp
@@ -24,4 +24,7 @@ int main()
         cout<<data[i]<<" ";
     cout<<"\n";
 		return 0;
+
 }
+//你好
+//test

From 4538c293e979b8b2d98713821cb2b06fdbd76c56 Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Tue, 10 Jul 2018 17:07:43 +0800
Subject: [PATCH 04/18] delete file

---
 test.cpp | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 test.cpp

diff --git a/test.cpp b/test.cpp
deleted file mode 100644
index a8e5999..0000000
--- a/test.cpp
+++ /dev/null
@@ -1 +0,0 @@
-121212121212121212121212121212121212121212121212dsfsdf

From d51438ad264c22d01b214bd9d834a9189c3cf62f Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Tue, 10 Jul 2018 17:09:57 +0800
Subject: [PATCH 05/18] add test

---
 test.cpp | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 test.cpp

diff --git a/test.cpp b/test.cpp
new file mode 100644
index 0000000..c459aef
--- /dev/null
+++ b/test.cpp
@@ -0,0 +1 @@
+isdfjkhasdl

From deb52129d68742f556870043745f52a8e1d7407b Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Wed, 11 Jul 2018 10:07:35 +0800
Subject: [PATCH 06/18] 18

---
 offer/18.md | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/offer/18.md b/offer/18.md
index e69de29..d397dcf 100644
--- a/offer/18.md
+++ b/offer/18.md
@@ -0,0 +1,44 @@
+#### 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
+
+***1.我开始的想法***
+```c
+class Solution {
+public:
+    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
+
+        vector<int> tempV;
+        for(int i = 0; i < popV.size(); i++){
+            tempV.push_back(popV[i]);
+        }
+        for(int j = 0; j < pushV.size(); j++){
+            if(pushV[j] != tempV[j])
+                return false;
+        }
+        return true;
+    }
+};
+```
+没有考虑到中途的操作，比如中途先弹出4，再压入5，最后的打印顺序是45321
+
+***2.正确的思路***  
+入：12345，出45321.借助一个辅助栈，先将入栈序列压入辅助栈，判断栈顶元素是否和出栈元素相等，如果相等，辅助栈出栈，出栈向上移。继续入栈，判断相等，出栈，上移操作。最后辅助栈为空，那么返回true。else 返回false  
+```c
+class Solution{
+public:
+  bool IsPopOrder(vector<int> pushV, vector<int> popV){
+    stack<int> temp;//辅助栈
+
+    int length = pushV.size();
+    int popIndex = 0;
+
+    for(int i = 0; i < length; i++){
+      temp.push(pushV[i]);
+      while(!temp.empty() && temp.top() == popV[popIndex]){
+        popIndex++;
+        temp.pop();
+      }//否则继续进栈
+    }
+    return temp.empty();//如果最后temp为空那麽就是正确的弹出序列
+  }
+}
+```

From 7afa8a15b001019cf3b9b5fa3eaad4d1af0ed608 Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Thu, 12 Jul 2018 20:05:48 +0800
Subject: [PATCH 07/18] last

---
 dynamic programming/06.md                     |  23 +++
 dynamic programming/07.md                     |  21 +++
 dynamic programming/08.md                     |  22 +++
 dynamic programming/digGlod.md                |   0
 dynamic programming/package.md                |   0
 ...17\345\210\227\344\271\213\345\222\214.md" |  47 ++++++
 eight_Queen.cpp                               | 158 ++++++++++++++++++
 offer/20.md                                   |   5 +
 offer/21.md                                   |  33 ++++
 9 files changed, 309 insertions(+)
 create mode 100644 dynamic programming/06.md
 create mode 100644 dynamic programming/07.md
 create mode 100644 dynamic programming/08.md
 create mode 100644 dynamic programming/digGlod.md
 create mode 100644 dynamic programming/package.md
 create mode 100644 "dynamic programming/\346\234\200\345\244\247\350\277\236\347\273\255\345\255\220\345\272\217\345\210\227\344\271\213\345\222\214.md"
 create mode 100644 eight_Queen.cpp
 create mode 100644 offer/21.md

diff --git a/dynamic programming/06.md b/dynamic programming/06.md
new file mode 100644
index 0000000..c5653d1
--- /dev/null
+++ b/dynamic programming/06.md	
@@ -0,0 +1,23 @@
+#### 大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。
+***动态规划***
+
+```c
+class Solution{
+public:
+  int Fibonacci(int n){
+    if(n == 0)
+    return 0;
+    if(n == 1 || n == 2)
+    return 1;
+    int i, a = 1, b = 1, result;
+    for(int i = 3; i < n; i++){
+      result = a + b;
+      a = b;
+      b = result;
+    }
+    return result;
+  }
+}
+```
+Fibonacci如果用递归虽然代码简单但是计算量会指数型增长
+Fibonacci数列和跳台阶都可以用动态规划
diff --git a/dynamic programming/07.md b/dynamic programming/07.md
new file mode 100644
index 0000000..306e12a
--- /dev/null
+++ b/dynamic programming/07.md	
@@ -0,0 +1,21 @@
+#### 一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
+```c
+class Solution{
+public:
+  int jumpFloor(int number){
+    if(number == 0)
+    return false;
+    if(number == 1 || number == 2)
+    return number;
+    else{
+      int result, a = 1, b = 2, i;
+      for(i = 3; i <= number; i++){
+        result = a + b;
+        a = b;
+        b = result;
+      }
+      return result;
+    }
+  }
+}
+```
diff --git a/dynamic programming/08.md b/dynamic programming/08.md
new file mode 100644
index 0000000..93c558e
--- /dev/null
+++ b/dynamic programming/08.md	
@@ -0,0 +1,22 @@
+#### 一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
+```c
+class Solution{
+public:
+  intjumpFloorll(int number){
+    if(number == 0)
+    return false;
+    if(number == 1)
+    return 1;
+    else{
+      int i, reslut; a = 1;
+      for(i = 2; i <= number; i++){
+        result = 2 * a;
+        a = result;
+      }
+      return reslut;
+    }
+  }
+};
+
+```
+ 
diff --git a/dynamic programming/digGlod.md b/dynamic programming/digGlod.md
new file mode 100644
index 0000000..e69de29
diff --git a/dynamic programming/package.md b/dynamic programming/package.md
new file mode 100644
index 0000000..e69de29
diff --git "a/dynamic programming/\346\234\200\345\244\247\350\277\236\347\273\255\345\255\220\345\272\217\345\210\227\344\271\213\345\222\214.md" "b/dynamic programming/\346\234\200\345\244\247\350\277\236\347\273\255\345\255\220\345\272\217\345\210\227\344\271\213\345\222\214.md"
new file mode 100644
index 0000000..68ff0a7
--- /dev/null
+++ "b/dynamic programming/\346\234\200\345\244\247\350\277\236\347\273\255\345\255\220\345\272\217\345\210\227\344\271\213\345\222\214.md"	
@@ -0,0 +1,47 @@
+#### 求取数组中最大连续子序列和，例如给定数组为A={1， 3， -2， 4， -5}， 则最大连续子序列和为6，即1+3+（-2）+ 4 = 6。  
+***o(N^2)***
+```c
+int maxsequnence(int arr[], int len)
+{
+  int max = 0;
+  for(int i = 0; i < len; i++)
+  {
+    sum = 0;
+    for(int j = i; j < len; j++)
+    {
+      sum += arr[j];
+      if(max < sum)
+      max = sum;
+    }
+  }
+  return max;
+}
+```
+
+***o(N)***  
+因为最大 连续子序列和只可能是以位置0～n-1中某个位置结尾。当遍历到第i个元素时，判断在它前面的连续子序列和是否大于0，如果大于0，则以位置i结尾的最大连续子序列和为元素i和前门的连续子序列和相加；否则，则以位置i结尾的最大连续子序列和为元素i。  
+```c
+maxsequnence2(int a[], int len)
+{
+  int maxsum , maxhere;
+  maxsum = maxhere = arr[0];
+
+  for(int i = 1; i < len; i++)
+  {
+    maxhere =  arr[i];
+    if(maxhere < 0)
+    {
+      maxsum = arr[i];
+    }
+    else
+    {
+      maxhere += arrr[i];
+      if(maxhere > maxsum)
+      {
+        maxsum = maxhere;
+      }
+    }
+  }
+  return maxsum;
+}
+```
diff --git a/eight_Queen.cpp b/eight_Queen.cpp
new file mode 100644
index 0000000..f374662
--- /dev/null
+++ b/eight_Queen.cpp
@@ -0,0 +1,158 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+static final int MAX_NUM = 8;
+int chessBoard[][] = new int[MAX_NUM][MAX_NUM];
+
+//判断落点是否符合规范
+boolean check(int x, int y)
+{
+  for(int i = 0; i < y; i++)
+  {
+    //检查纵向
+    if(chessBoard[x][i] == 1)
+    {
+      return false;
+    }
+
+    //检查左侧倾斜 x-1,y-1就是x,y的左斜上方一个
+    if(x-1-i >= 0 && chessBoard[x-1-i][y-1-i] == 1)
+    {
+      return false;
+    }
+
+    //检查左侧倾斜 x+1,y+1就是x,y的右斜上方一个
+    if(x+1+i >= 0 && chessBoard[x+1+i][y+1+i] == 1)
+    {
+      return false;
+    }
+  }
+  return true;
+}
+
+
+//递归回溯
+boolean settleQueen(int y){
+  //行数超过最大则已经找出答案
+  if(y == MAX_NUM){
+    return true;
+  }
+
+  //遍历当前行，逐一格子验证
+  for(int i = 0; i < MAX_NUM; i++)
+  {
+    //把当前行全部置0，防止回溯的时候有脏数据
+    for(int j = 0; j < MAX_NUM; j++)
+    {
+      chessBoard[i][j] == 0;
+    }
+    //检查落点是否符合，如果符合将落点置为1，并且继续下一轮递归
+    if(check(i,y))
+    {
+      chessBoard[i][y] == 1;
+      //如果下一层返回true那么就已经找到解法，无需再循环
+      if(settleQueen[y+1])
+      {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+
+//打印结果
+void printChessBoard()
+{
+  for(int i = 0; i < MAX_NUM; i++)
+  {
+    for(int j = 0; j < MAX_NUM; j++)
+    {
+      cout<<chessBoard[i][j];
+    }
+    cout<<"\n";
+  }
+}
+
+
+
+
+
+// int m[8][8] = {0};//表示棋盘，初始为0，表示未放置皇后
+// int num = 0;//解数目
+//
+// //对于棋盘前row-1行已放置好皇后
+// //检查在第row行、第column列放置一枚皇后是否可行
+// bool check(int row,int column)
+// {
+//     if(row==1) return true;
+//     int i,j;
+//     //纵向只能有一枚皇后
+//     for(i=0;i<=row-2;i++)
+//     {
+//         if(m[i][column-1]==1) return false;
+//     }
+//     //左上至右下只能有一枚皇后
+//     i = row-2;
+//     j = i-(row-column);
+//     while(i>=0&&j>=0)
+//     {
+//         if(m[i][j]==1) return false;
+//         i--;
+//         j--;
+//     }
+//     //右上至左下只能有一枚皇后
+//     i = row-2;
+//     j = row+column-i-2;
+//     while(i>=0&&j<=7)
+//     {
+//         if(m[i][j]==1) return false;
+//         i--;
+//         j++;
+//     }
+//     return true;
+// }
+//
+// //当已放置8枚皇后，为可行解时，输出棋盘
+// void output()
+// {
+//     int i,j;
+//     num++;
+//     printf("answer %d:\n",num);
+//     for(i=0;i<8;i++)
+//     {
+//         for(j=0;j<8;j++) printf("%d ",m[i][j]);
+//         printf("\n");
+//     }
+// }
+//
+// //采用递归函数实现八皇后回溯算法
+// //该函数求解当棋盘前row-1行已放置好皇后，在第row行放置皇后
+// void solve(int row)
+// {
+//     int j;
+//     //考虑在第row行的各列放置皇后
+//     for (j=0;j<8;j++)
+//     {
+//         //在其中一列放置皇后
+//         m[row-1][j] = 1;
+//         //检查在该列放置皇后是否可行
+//         if (check(row,j+1)==true)
+//         {
+//             //若该列可放置皇后，且该列为最后一列，则找到一可行解，输出
+//             if(row==8) output();
+//             //若该列可放置皇后，则向下一行，继续搜索、求解
+//             else solve(row+1);
+//         }
+//         //取出该列的皇后，进行回溯，在其他列放置皇后
+//         m[row-1][j] = 0;
+//     }
+// }
+//
+// //主函数
+// int main()
+// {
+//     //求解八皇后问题
+//     solve(1);
+//     return 0;
+// }
diff --git a/offer/20.md b/offer/20.md
index e69de29..b4b3cea 100644
--- a/offer/20.md
+++ b/offer/20.md
@@ -0,0 +1,5 @@
+#### 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果
+***什么是二叉搜索树（二叉排序树）***  
+（1）若左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值；  
+（2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；  
+（3）左、右子树也分别为二叉排序树；
diff --git a/offer/21.md b/offer/21.md
new file mode 100644
index 0000000..0abc781
--- /dev/null
+++ b/offer/21.md
@@ -0,0 +1,33 @@
+#### 输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
+***回溯法***
+代码尚未通过
+```c
+class Solution {
+public:
+    vector<string> Permutation(string str) {
+        vector<string> array;
+        if(str.size() == 0)
+            return array;
+        permutation_helper( str, array, 0);
+        return array;
+    }
+
+    private:
+    void permutation_helper(vector<string> str, vector<string> array, int begin ){
+        if(begin >= str.size())
+        {
+            array.push_back(str);
+
+        }
+
+        for(int i = begin; i < str.size(); i++)
+        {
+            swap(str[begin], str[i]);
+            permutation(str, array, begin + 1);
+            swap(str[begin], str[i]);
+        }
+    }
+};
+```
+
+回溯法就是隐含的深度优先搜索，类似的问题还有八皇后的问题。使用递归实现回溯。

From ae0ba79bbd705f10d0661f2c32c4fe8da84d076e Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Sun, 15 Jul 2018 21:16:19 +0800
Subject: [PATCH 08/18] :)

---
 dynamic programming/package.md                | 23 +++++++++++++++
 ...11\345\210\207\346\225\260\345\210\227.md" |  0
 ...5\255\220\345\272\217\345\210\227(LCS).md" |  0
 ...5\255\220\345\272\217\345\210\227(LIS).md" |  0
 .../\350\267\263\351\235\222\350\233\231.md"  |  0
 ...22\350\233\231\345\217\230\346\200\201.md" |  0
 ...15\345\244\215\345\255\220\344\270\262.md" | 28 +++++++++++++++++++
 7 files changed, 51 insertions(+)
 rename dynamic programming/06.md => "dynamic programming/\346\226\220\346\263\242\346\213\211\345\210\207\346\225\260\345\210\227.md" (100%)
 create mode 100644 "dynamic programming/\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227(LCS).md"
 create mode 100644 "dynamic programming/\346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227(LIS).md"
 rename dynamic programming/07.md => "dynamic programming/\350\267\263\351\235\222\350\233\231.md" (100%)
 rename dynamic programming/08.md => "dynamic programming/\350\267\263\351\235\222\350\233\231\345\217\230\346\200\201.md" (100%)
 create mode 100644 "\346\234\200\351\225\277\344\270\215\351\207\215\345\244\215\345\255\220\344\270\262.md"

diff --git a/dynamic programming/package.md b/dynamic programming/package.md
index e69de29..705fa92 100644
--- a/dynamic programming/package.md	
+++ b/dynamic programming/package.md	
@@ -0,0 +1,23 @@
+#### 有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。  
+背包容积为10，5种物品，    
+价值->重量  
+8 6  
+7 4  
+4 2  
+5 4  
+5 3  
+```c
+#include "stdio.h"
+define max(a,b) ((a)>(b)?(a):(b))
+
+main(){
+  int v = 10;
+  int n = 5;
+
+  int value[] = {0, 8, 7, 4, 5, 5};
+  int weight[] = {0, 6, 4, 2, 4, 3};
+
+  int i, j;
+  int dp[][];
+}
+```
diff --git a/dynamic programming/06.md "b/dynamic programming/\346\226\220\346\263\242\346\213\211\345\210\207\346\225\260\345\210\227.md"
similarity index 100%
rename from dynamic programming/06.md
rename to "dynamic programming/\346\226\220\346\263\242\346\213\211\345\210\207\346\225\260\345\210\227.md"
diff --git "a/dynamic programming/\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227(LCS).md" "b/dynamic programming/\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227(LCS).md"
new file mode 100644
index 0000000..e69de29
diff --git "a/dynamic programming/\346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227(LIS).md" "b/dynamic programming/\346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227(LIS).md"
new file mode 100644
index 0000000..e69de29
diff --git a/dynamic programming/07.md "b/dynamic programming/\350\267\263\351\235\222\350\233\231.md"
similarity index 100%
rename from dynamic programming/07.md
rename to "dynamic programming/\350\267\263\351\235\222\350\233\231.md"
diff --git a/dynamic programming/08.md "b/dynamic programming/\350\267\263\351\235\222\350\233\231\345\217\230\346\200\201.md"
similarity index 100%
rename from dynamic programming/08.md
rename to "dynamic programming/\350\267\263\351\235\222\350\233\231\345\217\230\346\200\201.md"
diff --git "a/\346\234\200\351\225\277\344\270\215\351\207\215\345\244\215\345\255\220\344\270\262.md" "b/\346\234\200\351\225\277\344\270\215\351\207\215\345\244\215\345\255\220\344\270\262.md"
new file mode 100644
index 0000000..98d8d95
--- /dev/null
+++ "b/\346\234\200\351\225\277\344\270\215\351\207\215\345\244\215\345\255\220\344\270\262.md"
@@ -0,0 +1,28 @@
+Given "abcabcbb", the answer is "abc", which the length is 3.
+Given "bbbbb", the answer is "b", with the length of 1.
+Given "pwwkew", the answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.  
+
+滑动窗口是数组/字符串问题中常用的抽象概念。窗口是数组/字符串中通常由开始和结束索引定义的元素范围，即[i，j)（左闭合，右开）。滑动窗口是一个窗口，将其两个边界滑动到某个方向。例如，如果我们通过一个元素将[i，j）向右滑动，则它变为[i + 1，j + 1）（左闭右开）。
+
+回到我们的问题。我们使用HashSet将字符存储在当前窗口[i，j）（j = i）。然后我们将索引j向右滑动。如果不在HashSet中，我们会进一步滑动j。这样做直到s[j]已经在HashSet中。在这一点上，我们发现没有重复字符的子字符串的最大大小从索引i开始。重复上面的步骤，我们就能得到我们的答案。
+
+```java
+public class Solution {
+    public int lengthOfLongestSubstring(String s) {
+        int n = s.length();
+        Set<Character> set = new HashSet<>();
+        int ans = 0, i = 0, j = 0;
+        while (i < n && j < n) {
+            // try to extend the range [i, j]
+            if (!set.contains(s.charAt(j))){
+                set.add(s.charAt(j++));
+                ans = Math.max(ans, j - i);
+            }
+            else {
+                set.remove(s.charAt(i++));
+            }
+        }
+        return ans;
+    }
+}
+```

From a003b2d97ff08a0657c45b448ea8e43d6a29bef4 Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Fri, 20 Jul 2018 12:53:32 +0800
Subject: [PATCH 09/18] something

---
 BinarySearch.cpp                              |  10 +-
 a.out                                         | Bin 8904 -> 9016 bytes
 binarySearch.cpp                              |  34 +++++++
 ...5\255\220\345\272\217\345\210\227(LIS).md" |  23 +++++
 insert_Sort.cpp                               |   1 -
 moveZerores.cpp                               |  39 ++++++++
 shell_Sort.cpp                                |  17 +++-
 ...2\345\272\217\347\256\227\346\263\225.cpp" |  86 ++++++++++++++++++
 8 files changed, 206 insertions(+), 4 deletions(-)
 create mode 100644 binarySearch.cpp
 create mode 100644 moveZerores.cpp
 create mode 100644 "\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"

diff --git a/BinarySearch.cpp b/BinarySearch.cpp
index bd6d9f6..39e6e09 100644
--- a/BinarySearch.cpp
+++ b/BinarySearch.cpp
@@ -1,8 +1,16 @@
+#include <iostream>
+
+int binarySearch(int array[], int n, int target){
+
+}
+
+
+
 int BinarySearch(int array[], int n, int value){
   int left = 0;
   int right = n - 1;
 
-  while(left <= right){
+  while(left <= right){//注意此处的边界 
     int middle = left + ((right - left) >> 1);//>> 1(二进制右移动一位相当于/2) 或者(right-left) / 2 + left 不会溢出
     if(array[middle] > value)
       right = middle - 1;
diff --git a/a.out b/a.out
index 60b07c223c538152766d26cd4d0a34524dc2b6c9..3c21350ba30efad0c507bc394025a5410e0cafea 100755
GIT binary patch
delta 3224
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

delta 3149
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

diff --git a/binarySearch.cpp b/binarySearch.cpp
new file mode 100644
index 0000000..ef506f7
--- /dev/null
+++ b/binarySearch.cpp
@@ -0,0 +1,34 @@
+include <iostream>
+
+using namespace std;
+//边界为【L, R】
+int binarySearch(int array[], int n, int target){
+    int l = 0;
+    int r = n - 1;
+    int middle = (r - l) / 2 + l;
+    while(l <= r){
+        if(target > array[middle] )
+            l = middle + 1;
+        else if(target < array[middle])
+            r = middle - 1;
+        else return array[middle];
+    }
+    return -1;
+}
+
+
+
+//边界为[L, R)
+int binarySearch2(int array[], int n, int target){
+    int l = 0;
+    int r = n;
+    int middle = l + (r - l) >> 1
+        while(l < r){
+            if(target > array[middle])
+                l = middle + 1;
+            else if(target < array[middle])
+                r = middle;
+            else return array[middle];
+        }
+    return -1;
+}
diff --git "a/dynamic programming/\346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227(LIS).md" "b/dynamic programming/\346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227(LIS).md"
index e69de29..4d41212 100644
--- "a/dynamic programming/\346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227(LIS).md"	
+++ "b/dynamic programming/\346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227(LIS).md"	
@@ -0,0 +1,23 @@
+设f(i)表示L中以ai为末元素的最长递增子序列的长度。则有如下的递推方程：
+
+这个递推方程的意思是，在求以ai为末元素的最长递增子序列时，找到所有序号在L前面且小于ai的元素aj，即j<i且aj<ai。如果这样的元素存在，那么对所有aj,都有一个以aj为末元素的最长递增子序列的长度f(j)，把其中最大的f(j)选出来，那么f(i)就等于最大的f(j)加上1，即以ai为末元素的最长递增子序列，等于以使f(j)最大的那个aj为末元素的递增子序列最末再加上ai；如果这样的元素不存在，那么ai自身构成一个长度为1的以ai为末元素的递增子序列。
+
+```c
+public void lis(float[] L)
+{
+  int n = L.length;
+  int []f = new int[n];
+  f[0] = 1;
+  for(int i = 1; i < n; i++){
+    f[i] = 1;
+    for(int j = 0; j < i; j++)
+    {
+      if(L[j] < L[i] && f[j] > f[i]-1)
+      {
+        f[i] = f[j] + 1;
+      }
+    }
+  }
+   
+}
+```
diff --git a/insert_Sort.cpp b/insert_Sort.cpp
index e8b6214..03c56a8 100644
--- a/insert_Sort.cpp
+++ b/insert_Sort.cpp
@@ -8,7 +8,6 @@ void InsertSort(int array[], int n)
     int temp = array[i];
       for (j = i - 1; j >= 0 && array[j] > temp; j--){
         array[j + 1] = array[j];
-
     }
     cout<<"*"<<j<<" ";
     array[j+1] = temp;
diff --git a/moveZerores.cpp b/moveZerores.cpp
new file mode 100644
index 0000000..841ad65
--- /dev/null
+++ b/moveZerores.cpp
@@ -0,0 +1,39 @@
+#include <iostream>
+#include <vector>
+
+
+using namespace std;
+
+class Solution{
+    public:
+        void moveZeroes(vector <int>& nums){
+            vector<int> nonZeroElements;
+            for(int i = 0; i < nums.size(); i++){
+                if(nums[i])
+                nonZeroElements.push_back(nums[i]);
+                }
+            for(int i = 0; i < nums.size(); i++){
+                nums[i] = nonZeroElements[i];
+            }
+
+            for(int i = nonZeroElements.size(); i < nums.size(); i++){
+                nums[i] = 0;
+            }
+
+        }
+    }
+}
+
+
+//不使用额外的空间
+void moveZeroes(vector<int>& nums){
+    int k = 0;
+    int i = 0;
+        for(; i < nums.size(); i++){
+            if(nums[i])
+                if(i != k)//如果全部是非0元素，那么就不需要自身和自身交换了
+                swap(nums[k++], nums[i]);
+            else
+                k++;
+        }
+}
diff --git a/shell_Sort.cpp b/shell_Sort.cpp
index 288894b..c3f3221 100644
--- a/shell_Sort.cpp
+++ b/shell_Sort.cpp
@@ -16,6 +16,21 @@ void Shell_sort(int *arr, int n)
   }
 }
 
+//错误原因：我用 tmp = i 后面的中间变量用array[tmp],这根本就没有成为中间量！！
+// void Shell_sort(int *array, int n){
+//   int i, j, gap;
+//   int tmp;
+//   for(gap = n / 2; gap > 0; gap /= 2){
+//     for(i = gap; i < n; ++i){
+//       tmp = i;
+//       for(j = i - gap; j >= 0 && array[j] > array[tmp]; j -= gap){
+//         array[j + gap] = array[j];
+//       }
+//       array[j + gap] = array[tmp];
+//     }
+//   }
+// }
+
 int main()
 {
      int data[]={5,1,19,22,3,1,23,6};    //输入待排序数组
@@ -26,5 +41,3 @@ int main()
 		return 0;
 
 }
-//你好
-//test
diff --git "a/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp" "b/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"
new file mode 100644
index 0000000..795956f
--- /dev/null
+++ "b/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"
@@ -0,0 +1,86 @@
+//1.冒泡排序
+void bubbleSort(int array[], int n)
+{
+  for(int i = 0; i < n - 1; i++){
+    for(int j = 0; j < n - 1 - i; j++){
+      if(array[j] > array[j + 1])
+      swap(array[j], array[j + 1]);
+    }
+  }
+}
+//冒泡优化 设置标志变量
+function bubbleSort2(int array[], int n)
+{
+  int i, j, change = 0;
+
+  for(i = 0; i < n - 1 && change != 0; i++){
+   change = 0;//这里置0是为了每一次比较，只要有一次没有交换就有序了
+    for(j = 0; j < n - 1 - i; j++){
+      if(array[j] > array[j + 1]){
+        swap(array[j] > array[j++]);
+        change = 1;
+      }
+    }
+  }
+}
+
+//2.选择排序
+void selectionSort(int array[], int n)
+{
+  int minIndex = 0;
+
+  for(int i = 0; i < n - 1; i++){
+    minIndex = i;
+    for(int j = i + 1; j < n; j++){
+      if(array[j] < array[minIndex]){
+        minIndex = j;
+      }
+    }
+    swap(array[minIndex], array[i]);
+  }
+}
+
+//插入排序
+void insertSort(int array[], int n)
+{
+  int i, j, tmp;
+
+  for(int i = 1; i < n; i++){
+    tmp = array[i];
+    for(int j = i - 1; j >= 0; j--){
+      if(array[j] > tmp)
+      {
+        array[j + 1] = array[j];
+      }else{
+        break;
+      }
+    }
+    array[j + 1] = tmp;// 到-1时终止循环，所以要加一
+  }
+}
+
+//插入排序
+void insertSort(int array[], int n){
+  for(int i = 0; i < n; i++){
+    int tmp = array[i];
+    for(int j = i -1; j >= 0 && array[j] > tmp; j--){
+      array[j + 1] = array[j];//将大的数向前移动
+    }
+    array[j + 1] = tmp;//将小的数插入到空位中
+  }
+}
+
+
+//希尔排序
+void shellSort(int *array, int n){
+  int i, j, gap;
+  for(gap = n / 2; gap > 0; gap /= 2){
+    for(int i = 0; i < n; i++){
+      int tmp = array[i];
+      for(int j = i + gap; j >= 0 && array[j] > tmp; j--){
+        array[j + gap] = array[j];
+      }
+      array[j + gap] = tmp;
+    }
+  }
+}

From 61612c5c2f62ed7ac5fa9ae2afb247d6115e65f0 Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Fri, 20 Jul 2018 16:41:09 +0800
Subject: [PATCH 10/18] something

---
 a.out                                         | Bin 9016 -> 13152 bytes
 merge_Sort.cpp                                |  12 ++--
 ...2\345\272\217\347\256\227\346\263\225.cpp" |  54 ++++++++++++++++++
 3 files changed, 60 insertions(+), 6 deletions(-)

diff --git a/a.out b/a.out
index 3c21350ba30efad0c507bc394025a5410e0cafea..4c67d4c12f44efc0a7bf32395795bb801168424a 100755
GIT binary patch
literal 13152
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
SM8(4*yK0r=evg2sDgFhA^8C;M

delta 3188
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

diff --git a/merge_Sort.cpp b/merge_Sort.cpp
index b5bed1c..f942030 100644
--- a/merge_Sort.cpp
+++ b/merge_Sort.cpp
@@ -3,20 +3,20 @@ using namespace std;
 //归并排序
 void merge(int arr[], int L, int M, int R)
 {
-  int LEFT_SIZE = M - L;
-  int RIGHT_SIZE = R - M + 1;
+  int LEFT_SIZE = M - L + 1;
+  int RIGHT_SIZE = R - M;
   int left[LEFT_SIZE];//定义左边的数组
   int right[RIGHT_SIZE];//定义右边的数组
   int i, j, k;
 
   //1.填充左边的数组
-  for(i = L; i < M; i++){
+  for(i = L; i <= M; i++){
     left[i-L] = arr[i];
   }
 
   //2.填充右边的数组
-  for(i = M; i <= R; i++){
-    right[i-M] = arr[i];
+  for(i = M + 1; i <= R; i++){
+    right[i - M -1] = arr[i];
   }
 
   //测试
@@ -59,7 +59,7 @@ void mergeSort(int arr[], int L, int R){
     int M = (L + R) / 2;
     mergeSort(arr, L, M);
     mergeSort(arr, M + 1, R);
-    merge(arr, L, M + 1, R);
+    merge(arr, L, M, R);
   }
 }
 
diff --git "a/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp" "b/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"
index 795956f..5191c2e 100644
--- "a/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"
+++ "b/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"
@@ -84,3 +84,57 @@ void shellSort(int *array, int n){
     }
   }
 }
+
+*******************************************************************
+//归并排序
+void merge(int arr[], int L, int M, int R){
+  int LEFT_SIZE = M - L + 1;
+  int RIGHT_SIZE = R - M;
+  int left[LEFT_SIZE];
+  int right[RIGHT_SIZE];
+
+  for(int i = L; i <= M; i++){//拆分的时候M是包含在右边的
+    left[i - L] = arr[i];
+  }
+
+  for(int i = M + 1; i <= R; i++){
+    right[i - M - 1] = arr[i];
+  }
+
+  //将两个数组合并为一个有序的数组
+  i = 0; j = 0; k = 0;
+  while(i < LEFT_SIZE && j < RIGHT_SIZE){
+    if(left[i] < right[j]){
+      arr[k] = left[i];
+      i++;
+      k++
+    }else{
+      arr[k] = right[j];
+      j++;
+      k++;
+    }
+  }
+
+  while(i < LEFT_SIZE){
+    arr[k] = left[i];
+    i++;
+    k++;
+  }
+
+  while(j < RIGHT_SIZE){
+    arr[k] = right[j];
+    i++;
+    k++;
+  }
+}
+
+//分治法
+void merge_sort(int arr[], int L, int R){
+  if(L == R)//如果只有一个元素
+  return;
+
+  int M = (L + R) / 2;//为什么要加L,不直接R/2 ? 右边的L是从M+1开始的，并不是0
+  merge_sort(arr, L, M);//这个时候M是包含在左边的
+  merge_sort(arr, M + 1, R);
+  merge(arr, L, M, R);//注意中点边界M 
+}

From 36dc810ef6153c1c8006b966c7ee8d9b65405087 Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Sat, 21 Jul 2018 14:55:54 +0800
Subject: [PATCH 11/18] something

---
 a.out                                         | Bin 13152 -> 13192 bytes
 quick_Sort.cpp                                |  15 ++--
 ...2\345\272\217\347\256\227\346\263\225.cpp" |  68 +++++++++++++++---
 3 files changed, 68 insertions(+), 15 deletions(-)

diff --git a/a.out b/a.out
index 4c67d4c12f44efc0a7bf32395795bb801168424a..9b5a397ce818987c3022a0a9a5b3fbc5db27391d 100755
GIT binary patch
delta 1884
zcmZuxdrVtZ96slkXK!y?pzOjB+cKWpfGXSE0=hA|^FSbWnZ$%ZC{AI`vJE!~7)R=4
zGhS;=*>Q1EXCzrNW7MekADjt>J!H$&F@qE5OzHx$KK>9#Hk8im@7#OKOHOjnch2|w
ze$RW`Nc+nj;bKe%O3s)k1f;DAVc^EFJId>~<=Cv#sF{9-uQ*PL4KjbY?e9B#+Xi-@
zc;0Ju{#2`+<cNu@;+0#85o|XnAVfj}H8FU&iKE{pj|Pa`7bS9cgaoB%5Xn*u4w0ap
zU1hdMf{iiR9&S0`NaQKf|A&h?$la52V<ad|%F+x-WN8-8<Rl3>j<K4UGr?n8xS%vs
zDb3nK$AQ<+eeR$%8y5!_skcb6KvMs{S^WF=3(A?ea;fleQol5_AbfLC$hhzv1YypW
zMKxU_@^vDQMop@!{`wSb0YkL7aB$R`S;_Irzp4r@mscJ~r4;Gg9)!s>OlkxChUK~l
zE-+V^;}ZIF$R3n3V<CdUV?llzcsjv%Vh^pgxE$|hx={4Tn5qt&*<>N!M={!G$>jnu
z`nDy%p=lM^yTDFDnFXLFp^c9LMS_W=4gk;>fibKXJglk+eSslRl%;7o-(F^O9)&AH
zHfIe&#|1~0C*6e_NvL!);I8@-_Rdo}qVLbq^@6XFeR8ahJ#(u19^fUwUce6_#~9!Z
zz&`<hxu>dj$g=}__W<&c%?tPhU?*TNU>Gn8I6;39ia0VyIcr&9=pR+}K>%d6@33ao
z+4!E67tq$#m1`^V^B8>}JWwe54ic9#qS|VIiF;H?+G9yhfh)5=4bLsG3y@&mZc4#S
z!R)Nzt59ew;Jlq{VrH`@I1Rj&4q9^(FThEmBi5Y4NjTkvt}+4VoxFO|8lVy&S>zt&
zY}-@o;g|xAV`Zo9Nvq<s9mVD_D-Ko_Pe09V=f-(u_5H)9x^d&DtsC{-gls6XB5z0W
zzksFsG(;>)Uf!3Oo8;+lYs&m5jBMJ3KsyBwhXi!a;I+vBch}&rrosW1HW5G`I$-+S
z>|MjE)d5u+e3emNCdF%<sgDDTQ5qVj)9ws9ljq280S2M}m)l7P^Tq7vG;2B<%5@oW
zb$Eqd1M4X*+A4%xORWmU1>(jq2L>dfZOg1@!7FXi;1Z0;mx0ft*KkH{9h}mkr!u3b
zi-ux~d2%8muBG|1;cqe>S<&)W^cS7xMEp7(DG;%Rx(h{oolX~s*~L&9i{o7uX9Lq@
z_b@BULO#Q4hpcS9Mt6es7~Je&?RC2tIltbbM<D(gEy7n2fz|IbX8(+#x~bK0oBmuV
z=GwHH1vF-8j3mg(cs2$62(2y>aRb{EI}FxA2aDcGe74)adoQgi-sGv@aHyxP)9c^W
zidviMw{*50?DBW{5A65){eH$g;L)_LhYlR<VjS%$-j=Yh&A*>sD1Jlnl~iKogS8)H
z#kbyN;@k=J#qu(9e2U{dJzKs>h=1Q24t$b9?H*TJ{Ns*eGp+WNrxA<ZXdJ`J5zkgm
i*qp4>IRF*(>j&4R4i)Lls}xr}lv=Y+znSPrsq;Uwk^^=C

delta 2142
zcmb7Edu$X%9G=;`qwV#!y_UkYl*g4vpW25N1S^qM*9?ZnLVHLkNE;|vD^Q`B#-u57
zKG<wex0xCnLSjvtP)SXSM-(KscSURgB}Y|4^q&oZc%>L$AW#bHZ|3$+DX4Lh-EZgj
zeZS|<?%pl>W-S-H+w%_C*CZpp)+D!o-=DQtjO-?3Rm6;{=uvz+?ez6Wdv}lD_$~FP
zs||167O&|Q)j@x!KrF(j!+*i1W9LB|Lc}MQa#$K?r6X}et<rPSYRMy25$}~6qO^1>
zyE+t)rj)mBBC2&kE~Free7+<=6rCtTs;m{r9o_&|<UUnyE08rsKCH@pq?35V7?ekd
zGDy6Gc)4;;8esLs_TNgM^F25dU)me&`G^y>f`WPCP`?u_pK;0cKS)EsN%Fp6NxcCJ
z35Ep{)CGtiQ02q1WW%xGBhoSM8BHFNj`IE8$?lV@mHbPxkScd5a<3})mdRRc5g?>C
zYbUA<&kg~MFcD=?O#n-PY#dP>npf_{V<%x&d{7bpw)^?x!B+0C`5Fz?4go@B<GEOX
zA-R_|F(mge;I(w~TKbZGY<{ZTQzjp7X<>;~PcP(F9U2RwdV1K#sx1k&6smIfy;a9t
zTA572tYWX+jmNtFN&Z(*rtabD(d~v|L@N5PJd@I#GHWkf^?&k>og&Hv>+t+0QW`m&
zO}6m#3Bw@1I$c^Pt(TscHqb!4E5A(En^voyi>j>SkTMv&JO_u)-caNT)ia@%UxXN8
z<qRC?a6e74PtQES8Y$Nqxr>vG8i2rKm=@R@@l3kk?oRuCsvCt1Zy83v9mdZj_!bS>
zX9*+Y^k@70Wgn#hKQzwDnbr(i;#;^6OhmQKU^~#i3Z!=OxQ8g0`V9l20Stk{-H?6#
z@y!~oNlZ)EoNnYHz6U!2D_7)Qf)6u(OV~b6+Y)Qa*(aX>*YHil=mN}zc#VJ}6g3Q}
z-!_b204whph7)3^L*!z>TEGgxX23?kFyIj?IdX))oAgCTq2Rtr_c>;-oDaTF!L=0P
zej~txl;nI<cv76Q;vLJ|R-dhHie*r6#Kq49>Ls|sFruA+F`cjtScDkg23Hx)5;JY=
z80%CLGqb;frv#{N8eq()g1hj%SD5_{-6KAc@Gz8_3sUSqD^@4jHHgaAsDpkyYqQWK
z`e)4Uw>;Bi{u?7?<ZeO9X!m{XP89uz-mOnTy6B%f_e(6iF4D{M3bVQ#5y5g(7Z1e<
zNQCSW!!(NL&9N^4D@G}(Dw!UfpIuT4TZHb-@idpEp};J6#M`_-OYs6%Mh*8$MLm<)
zowNj41z0C?p$hliz74b%SPj^ezjbRhBfn4EfjtInDir-gV#IvHWCJt^>{WQZsVE6e
zp5WK?SHYFBowFk9i;FlFn7%)9_7G<i(PEP|No1ibvt2luX2E?GeJ$ISQ4dO1|FTK-
zSJOklzQWn`d%D}hB4iveYk(H`sx#Ak%2?YOVBPdAo?3F*)HRwqXq&Hb)Bb|lKR>9z
zB+?IZTsWV;oa4%HnKOFVJYM|JgJub1aV01}v2Cr}v89f#%UwiI<SrFAtX;?r74@*_
zl)U$>TWjmL`S<5NhLhGV;Z)`J9Zf*{zsvVys$;8v?*nd&5VX;QMTPe0yqiRNp=gm9
zJ*XVp4^5?ui`^;FQyRr8T3=k0qMQ9ivDyD&@#BK%HeW&}lwC}(Jyej;mBaf-%`~s{
L5u8qIOLP7NBjRdR

diff --git a/quick_Sort.cpp b/quick_Sort.cpp
index 1c1138a..e619832 100644
--- a/quick_Sort.cpp
+++ b/quick_Sort.cpp
@@ -2,6 +2,7 @@
 using namespace std;
 
 //快速排序
+//快排也是采用分治法
 static void swap(int *a, int *b)//a,b都是地址
 {
   int tmp;
@@ -15,18 +16,20 @@ static int partition(int arr[], int left, int right)
   int i = left;
   int j = right;
 
-  int pivot = arr[left];
+  int pivot = arr[left];//将左边的选为基数
 
   while(i < j){
+
     while(i < j && arr[j] >= pivot){
-      --j;
+      j--;
     }
     while(i < j && arr[i] <= pivot){
-      ++i;
-    }//当i=j后 i还向前多移动一位
+      i++;
+    }
     if(i < j){
       swap(&arr[i], &arr[j]);//&符号取地址
     }
+
   }
   swap(&arr[left], &arr[i]);
   return i;//返回下标
@@ -39,8 +42,8 @@ static void quick_sort(int arr[], int left, int right)
 
   if(left < right){
     pivot_pos = partition(arr, left, right);//交换后的下标
-    quick_sort(arr, left, pivot_pos - 1);//前面的i多向前跑了一位
-    quick_sort(arr, pivot_pos + 1, right);//原本是从pivot_pos开始,但是上面-1了,下面就要+1
+    quick_sort(arr, left, pivot_pos);
+    quick_sort(arr, pivot_pos + 1, right);
   }
 }
 
diff --git "a/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp" "b/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"
index 5191c2e..6df1f99 100644
--- "a/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"
+++ "b/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"
@@ -1,7 +1,9 @@
 //1.冒泡排序
+//两两比较放到最后，每一趟都会选出一个最大或者最小
+//O(n^2)
 void bubbleSort(int array[], int n)
 {
-  for(int i = 0; i < n - 1; i++){
+  for(int i = 0; i < n - 1; i++){//i是比较的次数，一共要比较n-1次,这里的i从0开始，所以要<n-1
     for(int j = 0; j < n - 1 - i; j++){
       if(array[j] > array[j + 1])
       swap(array[j], array[j + 1]);
@@ -13,18 +15,20 @@ function bubbleSort2(int array[], int n)
 {
   int i, j, change = 0;
 
-  for(i = 0; i < n - 1 && change != 0; i++){
-   change = 0;//这里置0是为了每一次比较，只要有一次没有交换就有序了
+  for(i = 0; i < n - 1 && change != 0; i++){//如果没有交换(change=0)就终止循环
+   change = 0;//在n-1次比较中，只要有一次没有交换就有序了
     for(j = 0; j < n - 1 - i; j++){
       if(array[j] > array[j + 1]){
         swap(array[j] > array[j++]);
-        change = 1;
+        change = 1;//表示有交换
       }
     }
   }
 }
-
+********************************************************************************
 //2.选择排序
+//从后面的选出最小的放到前面
+//O(n^2)
 void selectionSort(int array[], int n)
 {
   int minIndex = 0;
@@ -39,8 +43,10 @@ void selectionSort(int array[], int n)
     swap(array[minIndex], array[i]);
   }
 }
-
+********************************************************************************
 //插入排序
+//把后面的按大小插入到前面
+//O(n^2)
 void insertSort(int array[], int n)
 {
   int i, j, tmp;
@@ -70,8 +76,9 @@ void insertSort(int array[], int n){
   }
 }
 
-
+********************************************************************************
 //希尔排序
+//基于插入排序，平均O(n^1.3)
 void shellSort(int *array, int n){
   int i, j, gap;
   for(gap = n / 2; gap > 0; gap /= 2){
@@ -85,8 +92,12 @@ void shellSort(int *array, int n){
   }
 }
 
-*******************************************************************
+********************************************************************************
 //归并排序
+//用到分治法的思想，将数组不断的分下去，分到最后只剩下一个元素就是有序的了，再来合并成有序的数组
+//分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，
+//然后将这些子问题的解组合为原问题的解。
+//O(nlogn)
 void merge(int arr[], int L, int M, int R){
   int LEFT_SIZE = M - L + 1;
   int RIGHT_SIZE = R - M;
@@ -136,5 +147,44 @@ void merge_sort(int arr[], int L, int R){
   int M = (L + R) / 2;//为什么要加L,不直接R/2 ? 右边的L是从M+1开始的，并不是0
   merge_sort(arr, L, M);//这个时候M是包含在左边的
   merge_sort(arr, M + 1, R);
-  merge(arr, L, M, R);//注意中点边界M 
+  merge(arr, L, M, R);//注意中点边界M
+}
+********************************************************************************
+
+//快速排序
+
+//选一个基数，分成两个数组
+int partition(int arr[], int left, int right)
+{
+  int i = left;//定义左右边界
+  int j = right;
+
+  int pivot = arr[left];//将左边的选为基数
+
+  while(i < j){
+    while(i < j && arr[i] < pivot){//从左到右的数小于基数 i就向右移
+      i++;
+    }
+
+    while(j > i && arr[j] > pivot){////从右到左的数小于基数 i就向左移
+      j--;
+    }
+    //不符合条件就交换
+    swap(arr[i], arr[j]);
+  }
+  //循环完了之后交换基数于i的位置
+  swap(arr[i], pivot);
+  return i;//返回i的下标
+}
+
+//分治法，递归去分解每一个数组
+void quick_sort(int arr[], int left, int right)
+{
+    int pivot_pos;
+
+    if(left < right){
+      pivot_pos = partition(arr, left, right);
+      quick_sort(arr, left, pivot_pos);
+      quick_sort(arr, pivot_pos + 1, right);
+    }
 }

From f3880877bc47d135e5d4eb6ec6a56b0f889fd8d1 Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Tue, 24 Jul 2018 16:18:43 +0800
Subject: [PATCH 12/18] =?UTF-8?q?=E5=B0=8F=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 BinarySearch.cpp                              |  8 +-----
 heap_Sort.cpp                                 |  2 +-
 merge_Sort.cpp                                |  2 +-
 quick_Sort.cpp                                |  2 +-
 ...2\345\272\217\347\256\227\346\263\225.cpp" | 25 ++++++++++++++++++-
 5 files changed, 28 insertions(+), 11 deletions(-)

diff --git a/BinarySearch.cpp b/BinarySearch.cpp
index 39e6e09..c815bd9 100644
--- a/BinarySearch.cpp
+++ b/BinarySearch.cpp
@@ -1,16 +1,10 @@
 #include <iostream>
 
-int binarySearch(int array[], int n, int target){
-
-}
-
-
-
 int BinarySearch(int array[], int n, int value){
   int left = 0;
   int right = n - 1;
 
-  while(left <= right){//注意此处的边界 
+  while(left <= right){//注意此处的边界
     int middle = left + ((right - left) >> 1);//>> 1(二进制右移动一位相当于/2) 或者(right-left) / 2 + left 不会溢出
     if(array[middle] > value)
       right = middle - 1;
diff --git a/heap_Sort.cpp b/heap_Sort.cpp
index 7849207..562b3a0 100644
--- a/heap_Sort.cpp
+++ b/heap_Sort.cpp
@@ -31,7 +31,7 @@ void HeapSort(ElemType A[], int n) {
     }
     //进行排序
     for (int i = n - 1; i > 0; --i) {
-        //最后一个元素和第一个元素进行比较
+        //最后一个元素和第一个元素进行交换 就是将大的元素放到数组后面然后继续调整为最大堆 
         ElemType temp = A[i];
         A[i] = A[0];
         A[0] = temp;
diff --git a/merge_Sort.cpp b/merge_Sort.cpp
index f942030..a7c0e11 100644
--- a/merge_Sort.cpp
+++ b/merge_Sort.cpp
@@ -26,7 +26,7 @@ void merge(int arr[], int L, int M, int R)
 
   //将两个数组合并
   i = 0; j = 0; k = L;
-  while (i < LEFT_SIZE && j < RIGHT_SIZE) {
+  while (i < LEFT_SIZE && j < RIGHT_SIZE) {//三个指针i,j是两个待合并的数组，k是合并的
     if(left[i] < right[j]){
       arr[k] = left[i];
       i++;
diff --git a/quick_Sort.cpp b/quick_Sort.cpp
index e619832..ff16d65 100644
--- a/quick_Sort.cpp
+++ b/quick_Sort.cpp
@@ -38,7 +38,7 @@ static int partition(int arr[], int left, int right)
 
 static void quick_sort(int arr[], int left, int right)
 {
-  int pivot_pos;
+  int pivot_pos;//将数组分开处的下标
 
   if(left < right){
     pivot_pos = partition(arr, left, right);//交换后的下标
diff --git "a/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp" "b/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"
index 6df1f99..2770c0e 100644
--- "a/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"
+++ "b/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"
@@ -161,7 +161,7 @@ int partition(int arr[], int left, int right)
 
   int pivot = arr[left];//将左边的选为基数
 
-  while(i < j){
+  while(i < j){；
     while(i < j && arr[i] < pivot){//从左到右的数小于基数 i就向右移
       i++;
     }
@@ -188,3 +188,26 @@ void quick_sort(int arr[], int left, int right)
       quick_sort(arr, pivot_pos + 1, right);
     }
 }
+
+********************************************************************************
+//堆排序
+//先建立大(小)顶堆，然后将顶元素与尾元素交换，重新构建大(小)顶堆
+void HeapAdjust(int arr[], int start, int end){
+  int tmp = arr[start];
+
+  for(int i = 2 * start + 1; i <= end; i++){
+    if(i < end && arr[i] < arr[i + 1]){
+      i++;
+    }
+
+    if(tmp > arr[i])
+    {
+      break;
+    }
+
+    arr[start] = arr[i];
+    start = i;
+  }
+
+  arr[start] = tmp;
+}

From cb3a418ff6b281973cade7e1be4ca35ebda012ae Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Thu, 2 Aug 2018 17:14:52 +0800
Subject: [PATCH 13/18] test

---
 get_dir.php | 21 +++++++++++++++++++++
 test.php    |  9 +++++++++
 2 files changed, 30 insertions(+)
 create mode 100644 get_dir.php
 create mode 100644 test.php

diff --git a/get_dir.php b/get_dir.php
new file mode 100644
index 0000000..59aee1e
--- /dev/null
+++ b/get_dir.php
@@ -0,0 +1,21 @@
+<?php
+function get_dir_info($path){
+if($handle = opendir($path)){
+    while (false !== ($file = readdir($handle))){
+      if((is_dir($path."/".$file) && $file != "." && $file != ".."))
+      {
+        get_dir_info($path."/".$file."/");
+      }
+      else{
+        if($file != "." && $file != "..")
+        {
+          echo $file."\n";
+        }
+      }
+    }
+    closedir($handle);
+    }
+}
+
+$pa = ".";
+get_dir_info($pa);
diff --git a/test.php b/test.php
new file mode 100644
index 0000000..d304b99
--- /dev/null
+++ b/test.php
@@ -0,0 +1,9 @@
+<?php
+
+$dir = ".";
+$handle = opendir($dir);
+//var_dump($handle);
+while(($file = readdir($handle)) !== false){
+    echo $file."\n";
+}
+iss533535353535353535353535353535353535353535353535353535353535353535353535353535353535353535353535353535353535

From 3515567a6ed546d24e74a215b7f7052014565ee1 Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Thu, 2 Aug 2018 17:16:26 +0800
Subject: [PATCH 14/18] add sometext [issue55]

---
 test.php | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test.php b/test.php
index d304b99..85506ed 100644
--- a/test.php
+++ b/test.php
@@ -6,4 +6,4 @@
 while(($file = readdir($handle)) !== false){
     echo $file."\n";
 }
-iss533535353535353535353535353535353535353535353535353535353535353535353535353535353535353535353535353535353535
+iss55

From 9b28d2b4b642acee48ab1cab5e6ce431c42ffe62 Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Thu, 2 Aug 2018 17:22:47 +0800
Subject: [PATCH 15/18] fixed the problem

---
 test.php | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test.php b/test.php
index d304b99..42dafb4 100644
--- a/test.php
+++ b/test.php
@@ -7,3 +7,4 @@
     echo $file."\n";
 }
 iss533535353535353535353535353535353535353535353535353535353535353535353535353535353535353535353535353535353535
+hotfix2

From 2593f9164296bdb6980ab46f3c26b2d045bd64ba Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Thu, 2 Aug 2018 17:26:34 +0800
Subject: [PATCH 16/18] double [issue55]

---
 test.php | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test.php b/test.php
index 85506ed..af276b7 100644
--- a/test.php
+++ b/test.php
@@ -7,3 +7,4 @@
     echo $file."\n";
 }
 iss55
+iss55 double

From 768c9635073b80ba3f6f6c0ba7a95c6d09f8b677 Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Fri, 10 Aug 2018 14:14:14 +0800
Subject: [PATCH 17/18] some changes

---
 BinarySearch.cpp | 8 ++++----
 get_dir.php      | 2 +-
 quick_Sort.cpp   | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/BinarySearch.cpp b/BinarySearch.cpp
index c815bd9..448288b 100644
--- a/BinarySearch.cpp
+++ b/BinarySearch.cpp
@@ -4,7 +4,7 @@ int BinarySearch(int array[], int n, int value){
   int left = 0;
   int right = n - 1;
 
-  while(left <= right){//注意此处的边界
+  while(left <= right){//注意此处的边界为什么要等于？只有一个元素的时候
     int middle = left + ((right - left) >> 1);//>> 1(二进制右移动一位相当于/2) 或者(right-left) / 2 + left 不会溢出
     if(array[middle] > value)
       right = middle - 1;
@@ -19,17 +19,17 @@ int BinarySearch(int array[], int n, int value){
 
 //递归写法
 int BinarySearch2(int array[], int start, int end, int key){
-  int middle = (right - left) >> 1 + left;
+  int middle = (end - start) >> 1 + start;
   if(middle == key)
   return middle;
   if(end <= start){
     return -1
   }
   else if(key > middle){
-    return BinarySearch2(array[], middle + 1, end);
+    return BinarySearch2(array[], middle + 1, end, key);
   }
   else if(key < middle){
-    return BinarySearch2(array[], start, middle - 1);
+    return BinarySearch2(array[], start, middle - 1, key);
   }
   return -1;
 }
diff --git a/get_dir.php b/get_dir.php
index 59aee1e..a866e0a 100644
--- a/get_dir.php
+++ b/get_dir.php
@@ -1,7 +1,7 @@
 <?php
 function get_dir_info($path){
 if($handle = opendir($path)){
-    while (false !== ($file = readdir($handle))){
+    while (false !== ($file = readdir($handle))){//注意要使用不全等
       if((is_dir($path."/".$file) && $file != "." && $file != ".."))
       {
         get_dir_info($path."/".$file."/");
diff --git a/quick_Sort.cpp b/quick_Sort.cpp
index ff16d65..eb30e04 100644
--- a/quick_Sort.cpp
+++ b/quick_Sort.cpp
@@ -11,7 +11,7 @@ static void swap(int *a, int *b)//a,b都是地址
   *b = tmp;
 }
 
-static int partition(int arr[], int left, int right)
+static int partition(int arr[], int left, int right)//将大于基数的放在基数右边，将小于基数的放在基数左边
 {
   int i = left;
   int j = right;

From 76c46ae513526aced9485efcb936d4eb6725c609 Mon Sep 17 00:00:00 2001
From: passenger <passengerlcw@gmail.com>
Date: Sun, 26 Aug 2018 16:03:51 +0800
Subject: [PATCH 18/18] =?UTF-8?q?=E5=B8=8C=E5=B0=94=E6=8E=92=E5=BA=8F?=
 =?UTF-8?q?=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...2\345\272\217\347\256\227\346\263\225.cpp" |  4 ++--
 ...22\345\272\217\351\223\276\350\241\250.md" | 24 +++++++++++++++++++
 2 files changed, 26 insertions(+), 2 deletions(-)
 create mode 100644 "\345\220\210\345\271\266\344\270\244\344\270\252\346\216\222\345\272\217\351\223\276\350\241\250.md"

diff --git "a/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp" "b/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"
index 2770c0e..af4b13b 100644
--- "a/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"
+++ "b/\345\215\201\344\270\252\346\216\222\345\272\217\347\256\227\346\263\225.cpp"
@@ -82,9 +82,9 @@ void insertSort(int array[], int n){
 void shellSort(int *array, int n){
   int i, j, gap;
   for(gap = n / 2; gap > 0; gap /= 2){
-    for(int i = 0; i < n; i++){
+    for(int i = gap; i < n; i++){
       int tmp = array[i];
-      for(int j = i + gap; j >= 0 && array[j] > tmp; j--){
+      for(int j = i + gap; j >= 0 && array[j] > tmp; j -= gap){
         array[j + gap] = array[j];
       }
       array[j + gap] = tmp;
diff --git "a/\345\220\210\345\271\266\344\270\244\344\270\252\346\216\222\345\272\217\351\223\276\350\241\250.md" "b/\345\220\210\345\271\266\344\270\244\344\270\252\346\216\222\345\272\217\351\223\276\350\241\250.md"
new file mode 100644
index 0000000..928eaa2
--- /dev/null
+++ "b/\345\220\210\345\271\266\344\270\244\344\270\252\346\216\222\345\272\217\351\223\276\350\241\250.md"
@@ -0,0 +1,24 @@
+#### 合并两个有序链表
+递归写法
+```c
+public ListNode merge(ListeNode list1, ListNode list2)
+{
+  if(list1 == null)
+  return list2;
+  if(list2 == null)
+  return list1;
+
+  ListNode listnode = null;
+  if(list1->val() < list2->val())
+  {
+    listnode = list1;
+    listnode.next = merge(list1->next,list2);
+  }
+  else{
+    listnode = list2;
+    listnode.next = merge(list1, list2->next);
+  }
+
+  return listnode;
+}
+```