From f8882723223b5fff1e68fe108f59bade700e51c8 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Thu, 11 Apr 2019 13:30:23 +0800
Subject: [PATCH 01/24] =?UTF-8?q?=E4=BA=8C=E5=8F=89=E6=A0=91=E7=9A=84?=
 =?UTF-8?q?=E6=9C=80=E5=B0=8F=E6=B7=B1=E5=BA=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 LeetCode/Doc/doc-sample.md                    |   2 +-
 ...23\346\236\204\344\275\277\347\224\250.md" |  29 +++++++
 ...00\345\260\217\346\267\261\345\272\246.md" |  18 ++++
 LeetCode/LeetCode.iml                         |  10 +++
 .../production/LeetCode/one/Solution.class    | Bin 0 -> 1707 bytes
 .../production/LeetCode/one/TreeNode.class    | Bin 0 -> 350 bytes
 .../LeetCode/samplepackage/Solution.class     | Bin 0 -> 277 bytes
 LeetCode/src/one/Solution.java                |  78 ++++++++++++++++++
 LeetCode/src/samplepackage/Solution.java      |   8 ++
 README.md                                     |   4 +
 10 files changed, 148 insertions(+), 1 deletion(-)
 create mode 100644 "LeetCode/Doc/java\344\270\255\345\270\270\350\247\201\346\225\260\346\215\256\347\273\223\346\236\204\344\275\277\347\224\250.md"
 create mode 100644 "LeetCode/Doc/\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md"
 create mode 100644 LeetCode/out/production/LeetCode/one/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/one/TreeNode.class
 create mode 100644 LeetCode/out/production/LeetCode/samplepackage/Solution.class
 create mode 100644 LeetCode/src/one/Solution.java
 create mode 100644 LeetCode/src/samplepackage/Solution.java

diff --git a/LeetCode/Doc/doc-sample.md b/LeetCode/Doc/doc-sample.md
index 03f0a1a..98e23ca 100644
--- a/LeetCode/Doc/doc-sample.md
+++ b/LeetCode/Doc/doc-sample.md
@@ -13,4 +13,4 @@
 
 ## 代码
 
-[这里](../Code/n.py)
\ No newline at end of file
+[这里](../src/n/Solution.java)
\ No newline at end of file
diff --git "a/LeetCode/Doc/java\344\270\255\345\270\270\350\247\201\346\225\260\346\215\256\347\273\223\346\236\204\344\275\277\347\224\250.md" "b/LeetCode/Doc/java\344\270\255\345\270\270\350\247\201\346\225\260\346\215\256\347\273\223\346\236\204\344\275\277\347\224\250.md"
new file mode 100644
index 0000000..c9977e3
--- /dev/null
+++ "b/LeetCode/Doc/java\344\270\255\345\270\270\350\247\201\346\225\260\346\215\256\347\273\223\346\236\204\344\275\277\347\224\250.md"
@@ -0,0 +1,29 @@
+# Java中常见数据结构的使用方法
+
+## 队列
+```java
+Queue<String> queue = new LinkedList<String>();
+//添加元素
+queue.offer("a");
+ //返回第一个元素，并在队列中删除
+String first=queue.poll();
+queue.element(); //返回第一个元素 
+queue.peek(); //返回第一个元素 
+        
+```
+## 栈
+
+Stack<Integer\> st = new Stack<Integer\>();
+
+| 序号 | 方法描述                                                     |
+| :--- | :----------------------------------------------------------- |
+| 1    | boolean empty()  测试堆栈是否为空。                          |
+| 2    | Object peek( ) 查看堆栈顶部的对象，但不从堆栈中移除它。      |
+| 3    | Object pop( ) 移除堆栈顶部的对象，并作为此函数的值返回该对象。 |
+| 4    | Object push(Object element) 把项压入堆栈顶部。               |
+| 5    | int search(Object element) 返回对象在堆栈中的位置，以 1 为基数。 |
+
+
+
+
+
diff --git "a/LeetCode/Doc/\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md" "b/LeetCode/Doc/\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md"
new file mode 100644
index 0000000..66064fb
--- /dev/null
+++ "b/LeetCode/Doc/\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md"
@@ -0,0 +1,18 @@
+# 二叉树的最小深度（minimum-depth-of-binary-tree）
+
+<center>知识点：</center>
+
+
+## 题目描述
+
+Given a binary tree, find its minimum depth.The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.
+
+给定一个二叉树，找出其最小的深度。最小的深度指的是从根节点到距离其最近的叶子节点之间路径中的节点数。
+
+## 解题思路
+
+利用层序遍历的思想，数据结构采用队列，从第一层开始在每一层的最后一个节点入队之后再多入一个null，标记当前层已经结束，这样每当出队的元素为null，则深度就可加一，附加判断当前节点是否是叶子节点即可。
+
+## 代码
+
+[这里](../src/one/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/LeetCode.iml b/LeetCode/LeetCode.iml
index c90834f..bb6b39c 100644
--- a/LeetCode/LeetCode.iml
+++ b/LeetCode/LeetCode.iml
@@ -7,5 +7,15 @@
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library">
+      <library name="JUnit4">
+        <CLASSES>
+          <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.12/junit-4.12.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
   </component>
 </module>
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/one/Solution.class b/LeetCode/out/production/LeetCode/one/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..3414c25259fb168ae88ab9864d8b1e51a6f4aa1e
GIT binary patch
literal 1707
zcmZuxOLH4V5dKD5X(f4OMUfwokpN>7OSWu*A0+WZU^_1pNq)#>NOH;AUfY{US|P6}
ze4`4ER8drMfg=}Rd<jM3N?euVgsb>3`~iyBH@ho41}@V*-92A-e?2q5{`KM|fC;Qc
z5XYp7_ag9NvIAFfO)l5vGNocV3>7nSnT?<W1r_g0IT@klgD~bWFSiR3+`vs0w*-PS
zX5F+40{%>PT|il|whVz-(X1QgR&B#*uIU?9S}qo?O})CVH%+<sjEcQ$?g?}jt-6t~
zSk;zoTJ>pSHCuIoc*e1>H4URo)amS^fV$ag%1!&wsgtRjmSqb>Z7+VMWwaO<FFw*g
z)$@d|<{cC9Lp8I0!)VyM0)n7D=WE+<wCn5t_t}~A6%~jTt=RhJ<C5NRdQx$lBnouw
z7<TD2iBdJTSz4fJ?(9-3HQi)?J(&kCepRpU<STa5tnW-aB<jr_(vtWeH*4SXcp_e%
zOpJMQ+>;ZYoD_&utX6Z=xMj)#MBDt1N<K7PL_(nJj2lkuv9VP&_iXl{;SLrxe2BXm
ziYN(aazbsgHDr*|kd@0I`aEwNUqY8vENNKAiiRZmRIF;Kpe%5~$>;RDwDHK;BpI=@
z61<58tnF>1DbSsHg&sG2I(wgYz}&l8YuNkFo#S3<Sk)?f$z=Z<Pj6;Xa{5Z<%Kn~h
z)OgxzF@Lvv$h7jy9DvO+7<!EpOgMF&H#2ub2370m=QD`&MF9$UyOH49#a*6KPzHvM
zAf8b1p_^;aF?OMcy5<I;7nisbk|C}<EH)S&pzWLC69oK+$MD@dg1?j-eh$Tlk8;A5
zN+I_g0fFyfQV9zD40TFLDkn&}j_(jiAAac<?E?pxO)5Vjbb_dqVWOuG9m_9><s8LD
zcD!v{*tH$}{cZY?MJY}r>(1K4T`!yJLnmHiQz^WTH}ED|$>J^kG6T4d%b3R%{u3G8
zrgarLY+wXiWT=XF@EOMNImYo7uHkD&OJXM2`~*HGVv6{r!J|lOY1;Vc@r9Gg$6TK{
z`TWf1QtJ8!Na5SG^dc1e6G;`9#UB_@aU~j0{Emc=ZeCfJZzlFRi3VN1hla_~5hAlv
z2~#Pg(mx=aQXU>4m{uN27W`iSa!j*4Tp$Z`h_Tm8>{WI#<U*d-KIqjRV?>4w`6y##
zq@P%_(g^&lG$q8mK$xe8z2bhOU#0)SF*<k+wBj+;d&&`_C8-3cl-tUba;gPRwP0@K
zDMFm?Q-nv70qP^kAoU;7Ih=cj*fU%>yPspcmB1oGeDiVKB|}9PSHdXD9MBS5UB&`d
z7_rLT8t!A=Y4(m=B8NM|^C7<SQMSilmpF1{J|fL=<SD1ws~o%>?I@$)r4}Ie053wy
Lc^~6M@L}Q~5P3zv

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/one/TreeNode.class b/LeetCode/out/production/LeetCode/one/TreeNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..31e12617ef05bc4c0e7b36894d3397293b174a24
GIT binary patch
literal 350
zcmYjMJx{_=6g`&~YHOj0iY6|Oz+e|Qjf)8hNrMBV`)hr|BehLxA^t4~W8&Zs@JAU>
zD}#BtpXc23?*0Dx`~q-|a}PF-U067AaOz+vuy!gF$V^~o`l%B1q9WJfvebHBJn9=k
zyELmcfzGYTO?5}&Xf}=+?uiS6$mDvyeNJ?_R7u9pASzOo#i}%Qy>Hsp+Pv_iSAn-E
zwq>fPrY3h6MYgR>kzZ}pPWkX~=A(^{!2iF8pkL!*rt($zkZg3yjjYi)#wD+@d7VY$
z96jLRpowl1g}H}AP?FgcEk1T8ACSq#J6dn7TIkaE8kK;0eYiMc4GjO-2=<yDu@1F_
Ics)1x1%07AY5)KL

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/samplepackage/Solution.class b/LeetCode/out/production/LeetCode/samplepackage/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..ebc48befa7b77dd0b539eaf9a4fe0fa4bdb0ceb7
GIT binary patch
literal 277
zcmZurJ#WHL3_OQ?&@>dpfLOah2eNc4VyV<ADnk&vlRnW$A9*Mw{a;K-4Ez9o6v9Dt
zt1X@G&OXcM%kc!@6}=EGbOJmD=o0*?E_5{`v_|74!F{)1iqK7Tp+4(Prpg6pMx1_P
zb2dvZb))a5TYc*tVVLZAvo&hV`46vDoLW;?+7@qwFtv4=s}J4W===>PYyRa3E<D2E
z|16=`EX9V4RXoquDzESiM_zA=q$Mrri;8a=@Lmp}y%-JxL0@bLYYRp<?%@HUD8i$l
GgXjvG-#YvN

literal 0
HcmV?d00001

diff --git a/LeetCode/src/one/Solution.java b/LeetCode/src/one/Solution.java
new file mode 100644
index 0000000..21b7d57
--- /dev/null
+++ b/LeetCode/src/one/Solution.java
@@ -0,0 +1,78 @@
+package one;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+
+    TreeNode(int x) {
+        val = x;
+    }
+}
+
+public class Solution {
+    public int run(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+
+        Queue<TreeNode> treeNodeQueue = new LinkedList<TreeNode>();
+        treeNodeQueue.offer(root);
+        treeNodeQueue.offer(null);
+
+
+        int minDepth = 1;
+
+        while (!treeNodeQueue.isEmpty()) {
+            TreeNode curNode = treeNodeQueue.poll();
+            if (curNode == null) {
+
+                if (treeNodeQueue.isEmpty()) {
+                    return minDepth;
+                } else {
+                    minDepth += 1;
+                    treeNodeQueue.offer(null);
+                }
+            } else {
+                if (curNode.left == null && curNode.right == null) {
+                    return minDepth;
+                }
+                if (curNode.left != null) {
+                    treeNodeQueue.offer(curNode.left);
+                }
+                if (curNode.right != null) {
+                    treeNodeQueue.offer(curNode.right);
+                }
+            }
+
+
+        }
+        return minDepth;
+    }
+
+
+
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        TreeNode root = new TreeNode(1);
+        TreeNode node2 = new TreeNode(2);
+        TreeNode node3 = new TreeNode(2);
+        TreeNode node4 = new TreeNode(2);
+        TreeNode node5 = new TreeNode(2);
+        root.left = node2;
+        root.right = node3;
+        node2.left = node4;
+        node2.right = node5;
+
+        System.out.println(solution.run(root));
+
+    }
+}
\ No newline at end of file
diff --git a/LeetCode/src/samplepackage/Solution.java b/LeetCode/src/samplepackage/Solution.java
new file mode 100644
index 0000000..757e974
--- /dev/null
+++ b/LeetCode/src/samplepackage/Solution.java
@@ -0,0 +1,8 @@
+package samplepackage;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+public class Solution {
+}
diff --git a/README.md b/README.md
index 7acad24..6dfc106 100644
--- a/README.md
+++ b/README.md
@@ -140,3 +140,7 @@
 
   
 
+# LeetCode
+
+- [求解二叉树的最小深度](./LeetCode/Doc/二叉树的最小深度.md)
+

From ae7c8084700a9d3e22404ba2e718d8dd747a6834 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Thu, 11 Apr 2019 16:15:17 +0800
Subject: [PATCH 02/24] update-readme

---
 LeetCode/Doc/doc-sample.md                    |  2 +-
 ...00\345\260\217\346\267\261\345\272\246.md" |  2 +-
 ...60\345\274\217\347\232\204\345\200\274.md" | 19 +++++++++++++++++++
 LeetCode/src/one/Solution.java                |  1 +
 4 files changed, 22 insertions(+), 2 deletions(-)
 create mode 100644 "LeetCode/Doc/\350\256\241\347\256\227\351\200\206\346\263\242\345\205\260\345\274\217\347\232\204\345\200\274.md"

diff --git a/LeetCode/Doc/doc-sample.md b/LeetCode/Doc/doc-sample.md
index 98e23ca..60703dc 100644
--- a/LeetCode/Doc/doc-sample.md
+++ b/LeetCode/Doc/doc-sample.md
@@ -1,4 +1,4 @@
-# candy
+# 
 
 <center>知识点：</center>
 
diff --git "a/LeetCode/Doc/\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md" "b/LeetCode/Doc/\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md"
index 66064fb..707a0d7 100644
--- "a/LeetCode/Doc/\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md"
+++ "b/LeetCode/Doc/\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md"
@@ -1,6 +1,6 @@
 # 二叉树的最小深度（minimum-depth-of-binary-tree）
 
-<center>知识点：</center>
+<center>知识点：树</center>
 
 
 ## 题目描述
diff --git "a/LeetCode/Doc/\350\256\241\347\256\227\351\200\206\346\263\242\345\205\260\345\274\217\347\232\204\345\200\274.md" "b/LeetCode/Doc/\350\256\241\347\256\227\351\200\206\346\263\242\345\205\260\345\274\217\347\232\204\345\200\274.md"
new file mode 100644
index 0000000..93f43cc
--- /dev/null
+++ "b/LeetCode/Doc/\350\256\241\347\256\227\351\200\206\346\263\242\345\205\260\345\274\217\347\232\204\345\200\274.md"
@@ -0,0 +1,19 @@
+# 计算逆波兰式的值
+
+<center>知识点：栈</center>
+
+
+## 题目描述
+
+计算逆波兰式的值，给定式子中合法的操作符有+、-、*、/，操作数可能是整型或者另一个表达式，比如：
+
+  > ["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9
+  > ["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6
+
+## 解题思路
+
+利用栈的思想求解
+
+## 代码
+
+[这里](../src/n/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/src/one/Solution.java b/LeetCode/src/one/Solution.java
index 21b7d57..7113c6a 100644
--- a/LeetCode/src/one/Solution.java
+++ b/LeetCode/src/one/Solution.java
@@ -41,6 +41,7 @@ public int run(TreeNode root) {
                     treeNodeQueue.offer(null);
                 }
             } else {
+                //判断当前节点是否是叶子节点
                 if (curNode.left == null && curNode.right == null) {
                     return minDepth;
                 }

From 8d6f08e951a749b9526063d6f299cb9337e52f49 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Thu, 11 Apr 2019 19:30:38 +0800
Subject: [PATCH 03/24] =?UTF-8?q?=E8=AE=A1=E7=AE=97=E6=B3=A2=E5=85=B0?=
 =?UTF-8?q?=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...60\345\274\217\347\232\204\345\200\274.md" |   8 ++-
 .../production/LeetCode/one/Solution.class    | Bin 1707 -> 1526 bytes
 .../production/LeetCode/two/Solution.class    | Bin 0 -> 1949 bytes
 LeetCode/src/two/Solution.java                |  59 ++++++++++++++++++
 4 files changed, 65 insertions(+), 2 deletions(-)
 create mode 100644 LeetCode/out/production/LeetCode/two/Solution.class
 create mode 100644 LeetCode/src/two/Solution.java

diff --git "a/LeetCode/Doc/\350\256\241\347\256\227\351\200\206\346\263\242\345\205\260\345\274\217\347\232\204\345\200\274.md" "b/LeetCode/Doc/\350\256\241\347\256\227\351\200\206\346\263\242\345\205\260\345\274\217\347\232\204\345\200\274.md"
index 93f43cc..62af31e 100644
--- "a/LeetCode/Doc/\350\256\241\347\256\227\351\200\206\346\263\242\345\205\260\345\274\217\347\232\204\345\200\274.md"
+++ "b/LeetCode/Doc/\350\256\241\347\256\227\351\200\206\346\263\242\345\205\260\345\274\217\347\232\204\345\200\274.md"
@@ -12,8 +12,12 @@
 
 ## 解题思路
 
-利用栈的思想求解
+从头遍历元素，如果当前元素不是+、0、*、/之一，即为数字，则将该字符串转化为数字后入栈，如果当前元素时运算符，则从栈中弹出连续的两个元素作为操作数，然后结合当前元素（操作符）计算当前式子的结果，然后将结果再次入栈，直至遍历完成。
 
+需要注意的一个细节是弹出的两个元素作为二元操作符两边时的顺序，举例：
+["2", "1", "/", "3", "*"]
+入栈后：[2,1]
+出栈时op1=1,op2=2,所以结果应该是op2/op1而不是op1/op2.
 ## 代码
 
-[这里](../src/n/Solution.java)
\ No newline at end of file
+[这里](../src/two/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/one/Solution.class b/LeetCode/out/production/LeetCode/one/Solution.class
index 3414c25259fb168ae88ab9864d8b1e51a6f4aa1e..6f19ddd61c9784f110e7aecf028fcf021d320164 100644
GIT binary patch
delta 739
zcmX|;TTfF#6otPzy`1)RK%iBu^$y;k7m6rQMJ*t5DFwwuk*AU#vDmZ`tMRQSKKP)C
zF-`md`sfoTKq84h!2jZ_F-DDh%H>S5X6-#QYoERL=a!$LJKz6({RRwh+o6rLO}~Rh
zI>bc=3|umB*=8_^&5(g%n~Z})+L7Q&kgJTC@S4MQZrEhk?}e3jR9-aRsMqy&Iuw!B
z!t+AvS*=t~<w}*uZZTJSTC*9|j4`gc$%N(>lL}p}xT(8quA8qGUCk6R%`~yygN15Y
zG^!O%J2N&p%`AD%VWKv3nt5gvZOu~ULS-d2x4h~$K3J|UyANv$-&$$qQLXXITADYl
zn$Lq0sSd%gL@C*o?7p5Y)VdIhh@iijjBrr6-nqabIwex3v|zaL$@5V~8WY};dV*z=
z6zQW(nipc;OELE?!@MKY)EK}gnfn|ehF4VH@2VMgRC0<|UU7`$QvW1RI3eia)Nb{i
zv(s|cC7DhF{=cUEZuN&Qn=|#6_V91Q7D3K(&itF)`XTRa*_XC)7PkoHwy_tzTj*Is
zd_wYjB;(y@zJ2D8CpHMgquvdIiKtI_BI+0Zg_hp<Cas$s*t4q+{o)d22{0<=j!B>6
zbjysBOfV#49$`|lQ?jO+BgX^sO<yK={*m)skoN%==#l=+fTo+iSfZ4rR~+()-XQU&
Xe@POuV&dtLIFf7?Y6g}P35&k}p~PvJ

delta 892
zcmX|=OHUJF6o#L#opySe0;OCE77;-!w57;J0WHc!0cp!M3c3M9g<{hxR^zTFE?j6r
zO#cBJ7qTG{NF;G<;@@!X)`d~ynV~YtoO#c8Ztpqgo1fl~zI)&Pe*OaVv*f|gfX)>U
zHU_+0WzZBurWn?_=0@kbDH0yMjOg4jzXKjQx#?z<F;gA)Fu^UI+xrUv)ix<%3hzdy
zn9AlSGEa(|3N4p;R8%;&vm2Yma#p=5)e=zDZLPgni$5=BbMa(0|2VUr%swmXOd3ov
zZE%MfgCr@1QOIZFOWT=Dy0D%xxJ1aH(-dKvE7rwAP7)RJ2DPMhW)0?;H)x_+XTe~R
zw4%nUms`tkl(%eK<?puTfLHoA9}Oje0g-j(w7nr*FK15CppFKShJ_t85)@6Dc`e_!
z_FYw9?$#2eC=ZFTPMjP)yrh>`^zn{Cb{Mj9^y83`FLQ>F)PwhxY$j@vGes4zIZLbT
z;v7%qZNtv_O7#<4yVyG9q!E|%4^283)Nk5#E|z@$z%K$evCB|QZsN5gnpr6v`HI87
z*A@AM>j+Q61a1K%p_X0TA#L>o&K7NTPh9Potv3i&NJ#LAjA4{&#-#BHtBtOcl&9pw
z7WtAAr=YB+O=<=OcUtUCt{&{dHKf#-!c7;E3cDXtOc(ouW4tRz7|CPw73~OL$^;Gp
z>HlC@J4KFD<c!7+a7CN61KhFljKf!|ibM~oKBQ(}(%P&}dS!JmjZ3bRpBWiVQU;i!
zo3yNER(hOcoO$tB5N(P3+_k!#I-y2XmWo6#N<>hI`z4RLESqE+m1T#di4OT&dIYs<
W;uPbuK!+r6mpc%$Zc(2_r~e;n;Cjda

diff --git a/LeetCode/out/production/LeetCode/two/Solution.class b/LeetCode/out/production/LeetCode/two/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..4c3d94a41d2a64433d2af9f57130c3f3546afc10
GIT binary patch
literal 1949
zcmZuxT~ixn6n@@hlie&E0t*3CErm)cfs~XF(-tVyqF5|nZ7?;oY8TkT(vZYtQ?28r
z{)qO{8)h7D^n!Nm*m1@?|Akk2>1F*G>ho@rNw8%0?4EPpv*+V^&gR#{AD;u5z^;xM
zW>s9#;lr$kw{^7Ps)jiY?`U{edgoQVr$fgzd9)z4_oe%~)D~4NX;{{<qG46V4IQ1B
z4dEuzQd`sU0WvCX2?VE|yyMOY_y^+|0cEbRWeY?WoxHtV+1s#7Yt}}N9&@p<Y2`9j
z$&q%=skl2%S)g^%{j88o7jhNXDdeXFRQrLIySch7&^35_ao2iaC39AOJDGM%PJVkT
zz966#igw9z?J<Flrig{SYj4{n=BNjZvd5BLuH;;SkmK5WYlZuEUN-bfUV(s<-?Bd!
z5Udb%Wgy$@IHm;wqt-y$wKneyv{%z{f*jkVi!CT+=L?SBb#(NH#rpUI|9@w?si*oR
zGfWirGA>y~4>yuZc1Vhf1Sw>lJ<H)l$73Z)u}a&VBj620WXd(91@v^GQrfiV9Z6BR
z&cKL7#=r@@P9{B+8e<WgVFMo`OXVD8h>|q0j@!hbfoQFJ19$L|fsgTtfxGf%VMF>h
z1=<?HRa%*dWD4>n#tCopN~qW}VB?;FKAcvuZD0q^krXQ%yY?m-4%(kqtQ?1p4mM#~
zJ)MfLb4`ndqCn?h{MBRb9oMd6uiTSZE;L8f$sl+;R(Yqo<lK0<h)&+k$k&K-u~Oa<
z7&xx<aplf72iAAHDX>ws8LWq8E-?owR5)+68txR5tNb)vCb6wOZcK-V?ol`AE6Si8
zcSYfR8KT+Ae+l{XLrA`Pe}h(%Pr+wk=n2I4RD3wed(d-+&_ms*2H+HWX$eUT?|j+!
zHKSYT%07cH`vm@_;pa2{loC}=ej_dqN0qV3fT_d+2M9bypBb!a-KJX8!lveFkMJ^a
zfY8s-CxdlG^*=?+B+n;9zLXvd9l-dO<*`W_q9iHvlmUwLrE1SiEMzLI_y{R~O5ewM
z+Ck4AP^8^UTlMU&fVA6aYn~kpru3*Ti#Qbd^HU@m=P7fPOpI@aV@wym>vgw}>4s~o
z=8895J2h8V!<DPK{D~OLw%*!DI1vjxMMN53DPsTdml_1D@*RsRUJL8!qTT`xVcy%w
zW;<Ezz*TD35ycwM*U^nX=zT$U|3Qyv!70&-KGB2Iq7VII6lcT);$jNJVg?Cu4Q*l>
z;~vR(5MrJ`@h197{u+MA8EPtX{zi!VS@(n(!C4F<fL3t@agv}&>T7EuwP7T<7@D|&
za~P4U!R$%K`8@#T8dc9mc{avr<`FqWtBP?U{>8Y8iI-SFi;A~Yq&zQODlXKo3GQhm
z5;1yA)BFqO3xxibSAd;g#HH#=;!AcVX&cjiLR;2vwx_d-X{NJW#B?@jcBHeasiqg7
zp_2<6UHSoCiQxluAK<md@|$upTp%tNIr}AyV$#E?x0;z&g6BO%e#)D8fS<@TKMo&z
KxXcqDX8r?u@QpwK

literal 0
HcmV?d00001

diff --git a/LeetCode/src/two/Solution.java b/LeetCode/src/two/Solution.java
new file mode 100644
index 0000000..782cd32
--- /dev/null
+++ b/LeetCode/src/two/Solution.java
@@ -0,0 +1,59 @@
+package two;
+
+import java.util.Stack;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+public class Solution {
+    public int evalRPN(String[] tokens) {
+        Stack<Integer> operateStack = new Stack<>();
+
+        int size = tokens.length;
+
+
+        for (int index = 0; index < size; index += 1) {
+            String itemToken = tokens[index];
+
+            if ("+".equals(itemToken) || "-".equals(itemToken) || "*".equals(itemToken) || "/".equals(itemToken)) {
+                Integer operate2 = operateStack.pop();
+                Integer operate1 = operateStack.pop();
+                Integer result = 0;
+                switch (itemToken) {
+                    case "+":
+
+                        result = operate1 + operate2;
+                        break;
+                    case "-":
+
+                        result = operate1 - operate2;
+                        break;
+                    case "*":
+                        result = operate1 * operate2;
+                        break;
+                    case "/":
+                        result = (Integer) operate1 / operate2;
+                        break;
+                    default:
+                        break;
+                }
+                operateStack.push(result);
+
+            } else {
+                operateStack.push(Integer.valueOf(itemToken));
+            }
+
+
+        }
+
+
+        return operateStack.pop();
+    }
+
+    public static void main(String[] args) {
+        String[] token = {"2","1","+","3","*"};
+        Solution solution = new Solution();
+        System.out.println(solution.evalRPN(token));
+    }
+}

From 36d37013e7688cc0e5d3c17b5b5c4142afd8ee7f Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Fri, 12 Apr 2019 10:54:15 +0800
Subject: [PATCH 04/24] =?UTF-8?q?=E5=90=8C=E4=B8=80=E6=9D=A1=E7=9B=B4?=
 =?UTF-8?q?=E7=BA=BF=E4=B8=8A=E7=9A=84=E6=9C=80=E5=A4=9A=E7=9A=84=E7=82=B9?=
 =?UTF-8?q?=E7=9A=84=E6=95=B0=E9=87=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...71\347\232\204\346\225\260\351\207\217.md" |  60 +++++++++
 ...60\345\274\217\347\232\204\345\200\274.md" |   8 +-
 .../out/production/LeetCode/three/Point.class | Bin 0 -> 444 bytes
 .../production/LeetCode/three/Solution.class  | Bin 0 -> 2874 bytes
 LeetCode/src/three/Solution.java              | 117 ++++++++++++++++++
 README.md                                     |   3 +-
 6 files changed, 186 insertions(+), 2 deletions(-)
 create mode 100644 "LeetCode/Doc/\345\220\214\344\270\200\346\235\241\347\233\264\347\272\277\344\270\212\347\232\204\346\234\200\345\244\232\347\232\204\347\202\271\347\232\204\346\225\260\351\207\217.md"
 create mode 100644 LeetCode/out/production/LeetCode/three/Point.class
 create mode 100644 LeetCode/out/production/LeetCode/three/Solution.class
 create mode 100644 LeetCode/src/three/Solution.java

diff --git "a/LeetCode/Doc/\345\220\214\344\270\200\346\235\241\347\233\264\347\272\277\344\270\212\347\232\204\346\234\200\345\244\232\347\232\204\347\202\271\347\232\204\346\225\260\351\207\217.md" "b/LeetCode/Doc/\345\220\214\344\270\200\346\235\241\347\233\264\347\272\277\344\270\212\347\232\204\346\234\200\345\244\232\347\232\204\347\202\271\347\232\204\346\225\260\351\207\217.md"
new file mode 100644
index 0000000..bd9b790
--- /dev/null
+++ "b/LeetCode/Doc/\345\220\214\344\270\200\346\235\241\347\233\264\347\272\277\344\270\212\347\232\204\346\234\200\345\244\232\347\232\204\347\202\271\347\232\204\346\225\260\351\207\217.md"
@@ -0,0 +1,60 @@
+# max-points-on-a-line(同一条直线上的最多的点的数量)
+
+<center>知识点：穷举</center>
+
+
+## 题目描述
+Given n points on a 2D plane, find the maximum number of points that lie on the same straight line.
+
+
+给定2D平面上的n个点，找到位于同一直线上的最大点的数量。
+
+
+## 解题思路
+
+首先明确如何量化"直线"这一概念，最简单的，我们可以固定一个起始点S（Start），然后遍历剩余的所有点，记做E（End），如果有两个E（记做E1和E2），满足$(E1.x-S.x)/(E1.y-S.y)=(E2.x-S.x)/(E2.y-S.y)$,那么就可以确定E2在S与E1确定的直线上，而$(E1.x-S.x)/(E1.y-S.y)$刚好表示的是以E1和S构成的直线的斜率。所以我们就可以得出结论：要确定三个点S、E1、E2是否在同一条直线上即E2在S、E1构成的唯一直线上，只要满足S-E1直线的斜率与S-E2直线的斜率相等即可。
+
+明确了如何判断三个点是否在一条直线之后我们再回过头来看这道题，n个点，找出点数最多的直线上的点的数量。注意，题目中没有说n个点两两都不相同，所以可能出现多个点的x、y相等，这时候应该多计算一个点(重复的点也是点)。我们可以使用两个循环，第一个循环从第一个点开始遍历所有点作为起始点S，第二个循环从起始点的下一个点遍历后面所有的点作为重点E，构建Map存储当前S对应的所有斜率下的最大点值，逻辑如下：
+
+```
+maxCount=0;
+for indexS from 0 to Length:
+		Map<斜率，点数量> map
+		//以indexS对应点为起点的所有直线中点数量的最大值
+		tempMaxCount=1
+		//与当前indexS对应点重合的点的数量
+		commonCount=0
+		for indexE from indexS+1 to Length:
+				if point[indexS]==point[indexE]:
+						//如果两个点重合
+						commonCount+=1
+				else :
+            斜率=求斜率的函数(point[indexS],point[indexE])
+            //如果当前斜率之前已经被加入Map中，则更新最大点数为原来的点数+1
+            if(map.containsKey(斜率)){
+              tempMaxCount=max(tempMaxCount,map.get(斜率)+1)
+              map.put(斜率，map.get(斜率)+1)
+            }else{
+              tempMaxCount=2
+              map.put(斜率，2)
+            }
+		maxCount=max(maxCount,tempMaxCount+commonCount)
+return maxCount
+				
+```
+
+以上就是完整的逻辑，有几个细节需要注意：
+
+- 斜率的精度
+
+  > 不管使用float还是double都会涉及斜率精度取舍的问题，所以这里建议使用字符串保存精度，方法是将两个点x距离和y距离的比值化为最简分数，然后转化为字符串表示
+
+- x距离或y距离为0
+
+  > 由于存在两个点在同一条横线或同一条竖线的可能，这是如果还是和化普通分数那样就不可取，比如0/4和0/9化为字符串后不一样，但是其表示的值是一样的，所以这种情况应该单独考虑
+
+完整逻辑请看详细代码。
+
+## 代码
+
+[这里](../src/three/Solution.java)
\ No newline at end of file
diff --git "a/LeetCode/Doc/\350\256\241\347\256\227\351\200\206\346\263\242\345\205\260\345\274\217\347\232\204\345\200\274.md" "b/LeetCode/Doc/\350\256\241\347\256\227\351\200\206\346\263\242\345\205\260\345\274\217\347\232\204\345\200\274.md"
index 62af31e..2274886 100644
--- "a/LeetCode/Doc/\350\256\241\347\256\227\351\200\206\346\263\242\345\205\260\345\274\217\347\232\204\345\200\274.md"
+++ "b/LeetCode/Doc/\350\256\241\347\256\227\351\200\206\346\263\242\345\205\260\345\274\217\347\232\204\345\200\274.md"
@@ -1,10 +1,16 @@
-# 计算逆波兰式的值
+# 计算逆波兰式的值(evaluate-reverse-polish-notation)
 
 <center>知识点：栈</center>
 
 
 ## 题目描述
 
+Evaluate the value of an arithmetic expression in Reverse Polish Notation.
+
+Valid operators are+,-,*,/. Each operand may be an integer or another expression.
+
+Some examples:
+
 计算逆波兰式的值，给定式子中合法的操作符有+、-、*、/，操作数可能是整型或者另一个表达式，比如：
 
   > ["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9
diff --git a/LeetCode/out/production/LeetCode/three/Point.class b/LeetCode/out/production/LeetCode/three/Point.class
new file mode 100644
index 0000000000000000000000000000000000000000..85de9badc056074a3af47b56075c3a4e97c07a9b
GIT binary patch
literal 444
zcmZvX%}T>S6ot=i+Q!z@#Qyoa=(2WUH|`WSqEIL*R0=L9b+A)n0x=bREEgiU@Bw@%
z@k|rMg^PRU-ou>l&U}4;d;&PaZXFeLYAB;?Wy{63iyeVHvqr2JLG{GMCOZ{4{e!8X
ze3sm4fj>5}zFa<pI=xY0M5j4UW-6Mh)Y!Q&%h}vK3L4{Vo@zb3PE4E~3o8B5$ihUi
zLP33!EYq33Fc#F9B+)W6Nqo3aPs&3Lbq`gz9@gLr*8iXcfxR<~RD3_Y3Kx2op~sI@
z_`4E|DJpD`Y8}Er2D@|4!qXqTLk7+pN>-fL)kTlmBna4``iuqaHqoHt<uT4aCyNXU
r<Smg7ogBGmk^BE3TST@Q>k!dhA$xi37wL1ATdZlavoCECTtfQ?497jr

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/three/Solution.class b/LeetCode/out/production/LeetCode/three/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..5a343d085b2a57e1984dfe0d1f83c365985ddaa2
GIT binary patch
literal 2874
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

literal 0
HcmV?d00001

diff --git a/LeetCode/src/three/Solution.java b/LeetCode/src/three/Solution.java
new file mode 100644
index 0000000..b48b4dc
--- /dev/null
+++ b/LeetCode/src/three/Solution.java
@@ -0,0 +1,117 @@
+package three;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+class Point {
+    int x;
+    int y;
+
+    Point() {
+        x = 0;
+        y = 0;
+    }
+
+    Point(int a, int b) {
+        x = a;
+        y = b;
+    }
+}
+
+public class Solution {
+    public int maxPoints(Point[] points) {
+
+        int length = points.length;
+        int maxPointCount = 0;
+        for (int startIndex = 0; startIndex < length; startIndex++) {
+            Map<String, Integer> maxPointMap = new HashMap<>();
+            int commonPointCount = 0;
+            int tempMaxCount = 1;
+            for (int endIndex = startIndex + 1; endIndex < length; endIndex++) {
+                int distanceX = points[startIndex].x - points[endIndex].x;
+                int distanceY = points[startIndex].y - points[endIndex].y;
+
+
+                if (distanceX == 0 && distanceY == 0) {
+                    commonPointCount += 1;
+                } else {
+                    String curStrDis;
+                    if (distanceX == 0) {
+                        curStrDis = "distanceX";
+                    } else if (distanceY == 0) {
+                        curStrDis = "distanceY";
+                    } else {
+                        int maxCommonDivisor = commonDivisor(distanceX, distanceY);
+                        if (maxCommonDivisor != 0) {
+                            distanceX = distanceX / maxCommonDivisor;
+                            distanceY = distanceY / maxCommonDivisor;
+                        }
+
+                        int flag = 0;
+
+                        if (distanceX < 0) {
+                            distanceX = -distanceX;
+                            flag++;
+                        }
+                        if (distanceY < 0) {
+                            distanceY = -distanceY;
+                            flag++;
+                        }
+
+                        curStrDis = String.valueOf(distanceX) + distanceY;
+                        if (flag == 1) {
+                            curStrDis = "-" + curStrDis;
+                        }
+                    }
+
+                    if (maxPointMap.containsKey(curStrDis)) {
+                        tempMaxCount = Math.max(tempMaxCount, maxPointMap.get(curStrDis) + 1);
+                        maxPointMap.put(curStrDis, maxPointMap.get(curStrDis) + 1);
+                    } else {
+                        //初始时put进去2，一个点是起始点，另一个点是当前点
+                        maxPointMap.put(curStrDis, 2);
+                        tempMaxCount = Math.max(tempMaxCount, 2);
+                    }
+                }
+            }
+            maxPointCount = Math.max(maxPointCount, tempMaxCount + commonPointCount);
+        }
+
+        return maxPointCount;
+    }
+
+    /**
+     * 求最大公约数
+     *
+     * @param a
+     * @param b
+     * @return
+     */
+    public static int commonDivisor(int a, int b) {
+        a = Math.abs(a);
+        b = Math.abs(b);
+        int count = 0;
+        for (int i = 1; i <= Math.min(a, b); i++) {
+            if (a % i == 0 && b % i == 0) {
+                count = i;
+            }
+        }
+        return count;
+    }
+
+    public static void main(String[] args) {
+
+        Point point1 = new Point(2, 3);
+        Point point2 = new Point(3, 3);
+        Point point3 = new Point(-5, 3);
+        Point point4 = new Point(9, -25);
+        Point[] points = {point1, point2, point3};
+        Solution solution = new Solution();
+        System.out.println(solution.maxPoints(points));
+    }
+
+}
diff --git a/README.md b/README.md
index 6dfc106..b69b56d 100644
--- a/README.md
+++ b/README.md
@@ -142,5 +142,6 @@
 
 # LeetCode
 
-- [求解二叉树的最小深度](./LeetCode/Doc/二叉树的最小深度.md)
+- [minimum-depth-of-binary-tree(求解二叉树的最小深度)](./LeetCode/Doc/二叉树的最小深度.md)
+- [evaluate-reverse-polish-notation(计算逆波兰式的值)](./LeetCode/Doc/计算逆波兰式的值.md)
 

From 74d496e4b2f4ee6ecea02fd5f58d4430a9c03cde Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Fri, 12 Apr 2019 10:54:53 +0800
Subject: [PATCH 05/24] =?UTF-8?q?=E5=90=8C=E4=B8=80=E6=9D=A1=E7=9B=B4?=
 =?UTF-8?q?=E7=BA=BF=E4=B8=8A=E7=9A=84=E6=9C=80=E5=A4=9A=E7=9A=84=E7=82=B9?=
 =?UTF-8?q?=E7=9A=84=E6=95=B0=E9=87=8F-update-readme?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index b69b56d..fd39bb1 100644
--- a/README.md
+++ b/README.md
@@ -144,4 +144,5 @@
 
 - [minimum-depth-of-binary-tree(求解二叉树的最小深度)](./LeetCode/Doc/二叉树的最小深度.md)
 - [evaluate-reverse-polish-notation(计算逆波兰式的值)](./LeetCode/Doc/计算逆波兰式的值.md)
+- [max-points-on-a-line(同一条直线上的最多的点的数量)](./LeetCode/Doc/同一条直线上的最多的点的数量.md)
 

From 510716d95893d8e8220584030e4573c9e7bea299 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Fri, 12 Apr 2019 13:49:32 +0800
Subject: [PATCH 06/24] =?UTF-8?q?=E5=AF=B9List=E6=8E=92=E5=BA=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...71\347\232\204\346\225\260\351\207\217.md" |  63 ++++++++++++
 .../Doc/\346\216\222\345\272\217List.md"      |  59 ++++++++++++
 .../production/LeetCode/four/ListNode.class   | Bin 0 -> 355 bytes
 .../production/LeetCode/four/Solution.class   | Bin 0 -> 1533 bytes
 LeetCode/src/four/Solution.java               |  90 ++++++++++++++++++
 README.md                                     |   1 +
 6 files changed, 213 insertions(+)
 create mode 100644 "LeetCode/Doc/\346\216\222\345\272\217List.md"
 create mode 100644 LeetCode/out/production/LeetCode/four/ListNode.class
 create mode 100644 LeetCode/out/production/LeetCode/four/Solution.class
 create mode 100644 LeetCode/src/four/Solution.java

diff --git "a/LeetCode/Doc/\345\220\214\344\270\200\346\235\241\347\233\264\347\272\277\344\270\212\347\232\204\346\234\200\345\244\232\347\232\204\347\202\271\347\232\204\346\225\260\351\207\217.md" "b/LeetCode/Doc/\345\220\214\344\270\200\346\235\241\347\233\264\347\272\277\344\270\212\347\232\204\346\234\200\345\244\232\347\232\204\347\202\271\347\232\204\346\225\260\351\207\217.md"
index bd9b790..c234c5c 100644
--- "a/LeetCode/Doc/\345\220\214\344\270\200\346\235\241\347\233\264\347\272\277\344\270\212\347\232\204\346\234\200\345\244\232\347\232\204\347\202\271\347\232\204\346\225\260\351\207\217.md"
+++ "b/LeetCode/Doc/\345\220\214\344\270\200\346\235\241\347\233\264\347\272\277\344\270\212\347\232\204\346\234\200\345\244\232\347\232\204\347\202\271\347\232\204\346\225\260\351\207\217.md"
@@ -55,6 +55,69 @@ return maxCount
 
 完整逻辑请看详细代码。
 
+```java
+public int maxPoints(Point[] points) {
+
+        int length = points.length;
+        int maxPointCount = 0;
+        for (int startIndex = 0; startIndex < length; startIndex++) {
+            Map<String, Integer> maxPointMap = new HashMap<>();
+            int commonPointCount = 0;
+            int tempMaxCount = 1;
+            for (int endIndex = startIndex + 1; endIndex < length; endIndex++) {
+                int distanceX = points[startIndex].x - points[endIndex].x;
+                int distanceY = points[startIndex].y - points[endIndex].y;
+
+
+                if (distanceX == 0 && distanceY == 0) {
+                    commonPointCount += 1;
+                } else {
+                    String curStrDis;
+                    if (distanceX == 0) {
+                        curStrDis = "distanceX";
+                    } else if (distanceY == 0) {
+                        curStrDis = "distanceY";
+                    } else {
+                        int maxCommonDivisor = commonDivisor(distanceX, distanceY);
+                        if (maxCommonDivisor != 0) {
+                            distanceX = distanceX / maxCommonDivisor;
+                            distanceY = distanceY / maxCommonDivisor;
+                        }
+
+                        int flag = 0;
+
+                        if (distanceX < 0) {
+                            distanceX = -distanceX;
+                            flag++;
+                        }
+                        if (distanceY < 0) {
+                            distanceY = -distanceY;
+                            flag++;
+                        }
+
+                        curStrDis = String.valueOf(distanceX) + distanceY;
+                        if (flag == 1) {
+                            curStrDis = "-" + curStrDis;
+                        }
+                    }
+
+                    if (maxPointMap.containsKey(curStrDis)) {
+                        tempMaxCount = Math.max(tempMaxCount, maxPointMap.get(curStrDis) + 1);
+                        maxPointMap.put(curStrDis, maxPointMap.get(curStrDis) + 1);
+                    } else {
+                        //初始时put进去2，一个点是起始点，另一个点是当前点
+                        maxPointMap.put(curStrDis, 2);
+                        tempMaxCount = Math.max(tempMaxCount, 2);
+                    }
+                }
+            }
+            maxPointCount = Math.max(maxPointCount, tempMaxCount + commonPointCount);
+        }
+
+        return maxPointCount;
+    }
+```
+
 ## 代码
 
 [这里](../src/three/Solution.java)
\ No newline at end of file
diff --git "a/LeetCode/Doc/\346\216\222\345\272\217List.md" "b/LeetCode/Doc/\346\216\222\345\272\217List.md"
new file mode 100644
index 0000000..6ff723a
--- /dev/null
+++ "b/LeetCode/Doc/\346\216\222\345\272\217List.md"
@@ -0,0 +1,59 @@
+# sort-list(排序List)
+
+<center>知识点：排序，链表</center>
+
+
+## 题目描述
+
+Sort a linked list in O(n log n) time using constant space complexity.
+
+使用常量空间在O（n log n）时间复杂度内对链表进行排序。
+
+## 解题思路
+
+首先思考常见排序算法的事件复杂度及空间复杂度（参考：[八大常见排序算法介绍](https://ai-exception.blog.csdn.net/article/details/79053814)）：
+
+| 排序方法     | 时间复杂度                            | 空间复杂度       |
+| ------------ | ------------------------------------- | ---------------- |
+| 直接插入排序 | $T(n)=O(n^2)$                         | $S(n)=O(1)$      |
+| 希尔排序     | $T(n)=O(n^{1.5})$                     | $S(n)=O(1)$      |
+| 冒泡排序     | $T(n)=O(n^2)$                         | $S(n)=O(1)$      |
+| 快速排序     | $T(n)=O(nlog_2n)$                     | $S(n)=O(log_2n)$ |
+| 选择排序     | $S(n)=O(1)$                           | $T(n)=O(n^2)$    |
+| 堆排序       | $T(n)=O(nlog_2n)$                     | $S(n)=O(1)$      |
+| 归并排序     | $T(n)=O(nlog_2n)$                     | $S(n)=O(n)$      |
+| 基数排序     | $T(n)=O(d*n)$ d为排序数中最大数的位数 | $S(n)=O(n)$      |
+
+从上表中可以看出，对数组而言，时间复杂度为$O（nlogn）$的排序算法有：快速排序、堆排序、归并排序。
+
+快速排序和堆排序都对数组中下标的使用较为依赖，相比之下，归并排序更适合链表，再考虑到数组中归并排序的空间复杂度之所以为$O(n)$是因为合并的时候需要用一个辅助数组记录合并后的值以保证原数组中的数字排序不被破坏，而链表可以使用指针保证这一点而不需要额外辅助数组，所以空间复杂度会降为$O(1)$.
+
+综上，使用归并排序可以很好地解决本问题。
+
+大致逻辑：
+
+```
+fun listSort(head):
+		centerNode=head链表的中间节点
+		//分而治之的思想，分别排序后一半链表和前一半链表
+		left=listSort(centerNode.next)
+		//将centerNode的next置位null，保证同样是head为头结点，现在的链表长度为原来的一半
+		right=centerNode.next=null
+		listSort(head)
+		//合并两个子链表
+		return merge(left,right)
+```
+
+这里涉及到找链表中间节点的问题，方法是使用两个指针p、q，初始时p指向head，q指向head.next，当q不为null时：
+
+```
+p=p.next
+q=q.next.next
+```
+
+利用两个指针行走速度快慢的不同最终实现找出链表的中间节点，注意处理好空指针异常即可，这个算法称为快慢指针算法。
+
+
+## 代码
+
+[这里](../src/four/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/four/ListNode.class b/LeetCode/out/production/LeetCode/four/ListNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..18aad38f378321ceea61d4e787c77f5630bb584a
GIT binary patch
literal 355
zcmY*Uu};G<6g($sLqkeR3I)W%*k))JHV_LEQl+RJin2SwfUA&5X;SsK7%C(NK7fxx
zoPmYm-Lubk=l4Fp-ai0b;><$_!yX(Q88~(^a&aPHZ)71LW&%#Bwv9lLJXUQTCwkq?
zs|R%@(7o2BZf>X;&n79`EqNo<rJA=dnX2z)R*(skDwjnnYi;g-q|-d>HGkL&cuOYd
z>P{PRe_0i6qpNbdk{jv6!>NxhTpxSr@%i5r0t2Ip3t2wJi)^KGPHK-QDK5B7hZ|Zf
zx`{9WM8Wc~&+hZIpu%W^=nWz|-@%H+4)!Z43w>h9AYec|q&>s|hAd$8YeVo8$^dFy
Kh6?J8H~a>=vOCED

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/four/Solution.class b/LeetCode/out/production/LeetCode/four/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..565bd802b69c653a8f4b017ed7beb2c1562b881e
GIT binary patch
literal 1533
zcmZuwU2hvz5Ixu4^?IF6lO}cO_9LV~8^<3pO`VTAX@Hhi7;FP|6^JMgYiHwZan{j#
z6Zk#6<h4jZBr5S}r2Yk7dE!5maAs{MQb4xvoI7{!%$#$_umAb&cK{`<r;tL?gpT)9
zNaC(6O9t+x=qZVN*}#f8iw0H|5*wcHg_{cT%)*v}_Ncq#Doj*8->o0+H{IZw)9lbQ
zRqeK%&XyB+vL8CNaL?;W^ltYsC^ovC!_e#c>k7$UHwdd<FI1Sz3{GWNXY%!h3wsvb
zbDf>DG-rVdW-oMt=$3-v`a5!8K@Yt49y4nlcb8_o5jw5!YR*B_6q)kgz8kdNLH**z
z`WMRow;d~V_YX#0D5wLL+IKu(VJ7oU^@Vff6g!UJE;hoz^V{o@Y);Uo5Yzv2%zk~g
zy)?A!F4~udc6n%5hL%r4@diS&w!>dVA=RM3E%%8hPcc3cdQp0@Fb2!Q8qyY~Fm2%m
zZZal%kr4@rxo@G2{ODwqLSgcp(C5t;ZcBvq-5<ncD#9&(<aBV01C!!>0UDH4<T}n>
zkyg>_*%PRr2x7RzH4!;yFhMM#48SBV({hq9%~dY{jW{ELr@1~-xt|gH1A6Xdt|qXa
z?_;*m$F%}CeN5+RYJ%nL`1G%=IDSREtmV}&h-Gtv^{lPi+6lCm%o>k6S!A=oRjxK`
z-e5;JaRqPVUCbdvTK8}p4{!$$F^>weQOBEuu7(}6Ki){Q=LtN*3{i~xO}s@E=iM~3
zrzuMXCTpb0^cpK(f;Oh!AYtG-zq7o<cNy?j)Ra*`^A+^%_z4pALRq5*8|1u3@&>sX
zKjNyb<w(ue$du<?tH-B*+FJhH8L4u7+UI3+5X}@s5+Y)q>#!LyTV#(#zQ|oNSfUET
zzJxrMxvp|P*6<PTlgS2ZWY)k3_zEB5TYMbdE)BXq)1?{lmDg=X8pN1=8?%uv7PgpQ
zbP+Wspud4N&|?0IX)<t*;zwhkRw;+f*7qU@UoTM=pcB*tBt#$q20>X9loX^3nv~OW
zB7)Jmk+Tia$0&#dqC?)+#G%<b%_}6gPhgglc2Xv$8ecKbr}iP40iUqB3a9i_T*qhB
zr%J_Y)TWNd_=27<`FToq4Lrv)w1_%XsfVv|MD{ZAy8}9Shf@Y-^M~^@1sCs8lNd8U
zXJ(n7+st(*(y7SG^F%spJ>YDnIfak;N()2=Ym9L^FY|ABMA>qDGn2N!{4p&43yW|N
AyZ`_I

literal 0
HcmV?d00001

diff --git a/LeetCode/src/four/Solution.java b/LeetCode/src/four/Solution.java
new file mode 100644
index 0000000..aee80bf
--- /dev/null
+++ b/LeetCode/src/four/Solution.java
@@ -0,0 +1,90 @@
+package four;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+
+/**
+ * Definition for singly-linked list.
+ */
+
+class ListNode {
+    int val;
+    ListNode next;
+
+    ListNode(int x) {
+        val = x;
+        next = null;
+    }
+}
+
+public class Solution {
+    public ListNode sortList(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+        ListNode startNode, endNode;
+        startNode = head;
+        endNode = head.next;
+
+        while (startNode != null && endNode != null && endNode.next != null) {
+            startNode = startNode.next;
+            endNode = endNode.next.next;
+        }
+
+
+        ListNode right = sortList(startNode.next);
+        startNode.next = null;
+        ListNode left = sortList(head);
+
+
+        return mergeList(left, right);
+    }
+
+    private ListNode mergeList(ListNode left, ListNode right) {
+        ListNode tempListNode = new ListNode(0);
+        ListNode p = tempListNode;
+
+        while (left != null && right != null) {
+            if (left.val < right.val) {
+                p.next = left;
+                p = p.next;
+                left = left.next;
+            } else {
+                p.next = right;
+                p = p.next;
+                right = right.next;
+            }
+        }
+        if (left != null) {
+            p.next = left;
+        }
+        if (right != null) {
+            p.next = right;
+        }
+
+
+        return tempListNode.next;
+    }
+
+    public static void main(String[] args) {
+        ListNode head = new ListNode(1);
+        ListNode node2 = new ListNode(2);
+        ListNode node3 = new ListNode(3);
+        ListNode node4 = new ListNode(4);
+        ListNode node5 = new ListNode(5);
+        ListNode node6 = new ListNode(6);
+        ListNode node7 = new ListNode(7);
+
+        head.next = node7;
+        node7.next = node3;
+        node3.next = node2;
+        node2.next = node4;
+        node4.next = node5;
+
+        Solution solution = new Solution();
+        head = solution.sortList(head);
+        int a = 0;
+    }
+}
diff --git a/README.md b/README.md
index fd39bb1..d383043 100644
--- a/README.md
+++ b/README.md
@@ -145,4 +145,5 @@
 - [minimum-depth-of-binary-tree(求解二叉树的最小深度)](./LeetCode/Doc/二叉树的最小深度.md)
 - [evaluate-reverse-polish-notation(计算逆波兰式的值)](./LeetCode/Doc/计算逆波兰式的值.md)
 - [max-points-on-a-line(同一条直线上的最多的点的数量)](./LeetCode/Doc/同一条直线上的最多的点的数量.md)
+- [sort-list(排序List)](./LeetCode/Doc/排序List.md.md)
 

From 3603b49229f776de848afda14d10d50d69cdd9dd Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Fri, 12 Apr 2019 13:50:13 +0800
Subject: [PATCH 07/24] update-readme

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index d383043..54dcb6d 100644
--- a/README.md
+++ b/README.md
@@ -145,5 +145,5 @@
 - [minimum-depth-of-binary-tree(求解二叉树的最小深度)](./LeetCode/Doc/二叉树的最小深度.md)
 - [evaluate-reverse-polish-notation(计算逆波兰式的值)](./LeetCode/Doc/计算逆波兰式的值.md)
 - [max-points-on-a-line(同一条直线上的最多的点的数量)](./LeetCode/Doc/同一条直线上的最多的点的数量.md)
-- [sort-list(排序List)](./LeetCode/Doc/排序List.md.md)
+- [sort-list(排序List)](./LeetCode/Doc/排序List.md)
 

From 82975ee12710fceafb6881ea90356d45c8017b78 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Sat, 13 Apr 2019 11:33:57 +0800
Subject: [PATCH 08/24] inertion-sort-list

---
 ...33\350\241\214\346\216\222\345\272\217.md" |  30 ++++++++
 .../production/LeetCode/five/ListNode.class   | Bin 0 -> 355 bytes
 .../production/LeetCode/five/Solution.class   | Bin 0 -> 1166 bytes
 LeetCode/src/five/Solution.java               |  70 ++++++++++++++++++
 README.md                                     |   1 +
 5 files changed, 101 insertions(+)
 create mode 100644 "LeetCode/Doc/\344\275\277\347\224\250\346\217\222\345\205\245\346\216\222\345\272\217\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\216\222\345\272\217.md"
 create mode 100644 LeetCode/out/production/LeetCode/five/ListNode.class
 create mode 100644 LeetCode/out/production/LeetCode/five/Solution.class
 create mode 100644 LeetCode/src/five/Solution.java

diff --git "a/LeetCode/Doc/\344\275\277\347\224\250\346\217\222\345\205\245\346\216\222\345\272\217\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\216\222\345\272\217.md" "b/LeetCode/Doc/\344\275\277\347\224\250\346\217\222\345\205\245\346\216\222\345\272\217\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\216\222\345\272\217.md"
new file mode 100644
index 0000000..8f7ed29
--- /dev/null
+++ "b/LeetCode/Doc/\344\275\277\347\224\250\346\217\222\345\205\245\346\216\222\345\272\217\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\216\222\345\272\217.md"
@@ -0,0 +1,30 @@
+# insertion-sort-list(使用插入排序对链表进行排序)
+
+<center>知识点：</center>
+
+
+## 题目描述
+
+Sort a linked list using insertion sort.
+
+## 解题思路
+
+首先明确什么是数组的插入排序：
+首先将第二个数与第一个数进行对比，如果第二个数比第一个数小，则将第二个数插入到第一个数之前，这样保证前两个数是有序的；
+接下来将第三个数与前两个数对比，发现有比第三个数大的数即将第三个数插入到对应数的前面，这样一次插入可保证前三个数是有序的；
+以此类推，将后面的i个数分别其前面的i-1个数进行对比，并将其插入到第一个比其大的数前面，最后即可完成排序。
+
+链表与数组相比唯一的不同在于链表不能通过下标访问元素，而且链表不能像数组那样通过下标减1的方式访问到上一个元素，针对这种情况我们将上面的算法做出如下改进：
+
+​     使用curNode、nextNode两个指针，curNode初始指向head，nextNode初始指向curNode.next，curNode的意思是从head节点开始到curNode节点之间的所有元素均为有序的，这在初始时时成立的（初始时curNode=head，所以当然成立），nextNode指向的是curNode的下一个元素，我们使用这个nextNode指针的目的是判断已经确定的有序链表[head,curNode]之外的下一个节点与当前有序链表的关系，具体的：
+
+- 如果nextNode.val>=curNode.val，那么说明[head,curNode]+nextNode构成的链表也是有序的，所以应该讲curNode向后移，即curNode=curNode.next，同时nextNode=curNode.next.
+- 如果nextNode.val<curNode.val，这个时候我们就需要将nextNode这个节点插入到之前有序链表的某一个位置，以保证[head,curNode]+headNode构成的链表是有序的，那么插在那个位置呢？就需要从head节点开始往后找了，方法是找到第一个比nextNode.val大的节点记为P，然后将nextNode插入到P之前即可，需要注意的是链表插入的时候需要借助一个辅助指针记住插入位置的前一个节点以方便插入。
+- 如果nextNode==null，说明整个链表排序完成，返回即可。
+
+
+
+
+## 代码
+
+[这里](../src/five/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/five/ListNode.class b/LeetCode/out/production/LeetCode/five/ListNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..4916f51c6de92987c9aaf298786b13299b417ebb
GIT binary patch
literal 355
zcmY*U!A^rf6r2TG1gX@jRpZ5D%b{GnX}p-2G$HMwhWmo6ZiA3eApI>5jfn?8z>hM{
zMlWXb=IxuEH*eq9_s1uIE1di2;mCu7V*@8H#x70;>`oQ}VlLp6YTF2e$&>C>oajxn
zs2<g|K>tRUy1AudGM}bQcjS#wmuk_zW~zRWSwUu$RJkltS!+}OkxuiXH=M8)@K;q^
z=jvV?@nBUIZKJDlww9d?;NvVnA8vp>czpi%3xT0g#f2=N<7Kv1Ie%(TrYSDDOphB{
z40aP?42Xi^W1l(TZApdEgwZ=hbg_dKi5=`WQWgfp5sg5p!^*<}Psjkqziq6HDGe~>
L7%qfERu)D-mk2wR

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/five/Solution.class b/LeetCode/out/production/LeetCode/five/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..882323c3ef884aae830c7356e7f2b0d856938320
GIT binary patch
literal 1166
zcmZuwOHUJF6g?lE>5K9z6&;Z`NMTwEh%c(3!3QLz#FSvb)ldc)C{t3V1l$;Rt~7Du
zT4TZ%6O=>}myq~3jQ_!fi07LYNQ_DI-Fxo)o;&^i=j%5BLl_7mfUW>Mxavc9kTNPk
zj}N^;c+n*v-G`Wf_l{*-&WL~~+A|}djO7<hftr+Mo9W`(yjhqw=5w@!Q~9isn=uNO
z#AT!6EL$5gdePc66PbLj=va9>DNtwG8)iX*OupcxtPMw?HChUjD9tX(o`0}FbvD1g
zJ+(M(uC0%o#==?UvlM|~DWv2MSoVUsC5v(LWjDj`oF)6R#X`wfm2r&h>ZGym&P_%b
zzGhgqKtuFdYQ@+z5;?<ON@SdZWiKUNB8<WkSF8VzTR^qha<D811pFK2)j3}#Uo2$J
zN0ub5>Xec`*&~D?Dnp1PLXXSX>0Z*)7eWI4r=HWq5b6*Xs6C%?YJSDcl1{}ox1@+p
z$Z<WJMovIXppBOe@EZWn&1q1{H$;@66qIW3KEx*~6{zCtb&X+EQxBB_P=i_`9uZ-_
zOcvWL=A-SMeu$vHhl(Sp`tAWdvz~n@lQI1>D)e;x5Kf%VVMS98(X1(ZP>I#|2uq!I
z=}qsP{Lqvm_+tdSv0+upVXx+8q?_^q5lxjgRodv<Ir*v4#U63D4i!z&yc9bpuiYvf
z&Eu{!hX(2qZhe9H5|M^RTtO3B$V?l$(T-c_z$iNLm?(uPo<PSmVwgi8mdKNher#b7
zFK`X7_+NU1n|O=cE=A*{VH!!)vxmxz>+BODiQQObuLu-LQkg)hU8Id48D4Uh2q|yE
zb50cDw3iv#jzFb2MvV`R{QX9NZ%g19{*s~T7h?nN^rahqWS+{r8<Kf1nNLYYl_!vj
zLM5%o$V)8F=K$W>efZ=x^e^x~JwJLo{H$`9wMTg3Q8IK7t+<aajFE!}-0Gpb?NF&3
kn#mp*9WU<_CVQ>!K8?(6bNA_E&31k`3is_`bOk#90`+^^2><{9

literal 0
HcmV?d00001

diff --git a/LeetCode/src/five/Solution.java b/LeetCode/src/five/Solution.java
new file mode 100644
index 0000000..14390b2
--- /dev/null
+++ b/LeetCode/src/five/Solution.java
@@ -0,0 +1,70 @@
+package five;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+
+class ListNode {
+    int val;
+    ListNode next;
+
+    ListNode(int x) {
+        val = x;
+        next = null;
+    }
+}
+
+public class Solution {
+    public ListNode insertionSortList(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+
+        ListNode tempHead = new ListNode(0);
+        tempHead.next = head;
+
+
+        ListNode curNode = head;
+        ListNode indexNode;
+
+        while (curNode != null) {
+
+            indexNode = curNode.next;
+            while (indexNode != null && indexNode.val >= curNode.val) {
+                indexNode = indexNode.next;
+                curNode = curNode.next;
+            }
+
+            if (indexNode == null) {
+                return tempHead.next;
+            }
+
+            ListNode copyOfTempHead = tempHead;
+            ListNode copyOfHead = tempHead.next;
+
+            while (copyOfHead.val < indexNode.val) {
+                copyOfTempHead = copyOfTempHead.next;
+                copyOfHead = copyOfHead.next;
+            }
+            copyOfTempHead.next = indexNode;
+            curNode.next = indexNode.next;
+            indexNode.next = copyOfHead;
+
+
+        }
+
+        return tempHead.next;
+    }
+
+    public static void main(String[] args) {
+        ListNode head = new ListNode(3);
+        ListNode node2 = new ListNode(2);
+        ListNode node1 = new ListNode(1);
+        head.next = node2;
+        node2.next = node1;
+
+        Solution solution = new Solution();
+        solution.insertionSortList(head);
+    }
+}
diff --git a/README.md b/README.md
index 54dcb6d..58122bf 100644
--- a/README.md
+++ b/README.md
@@ -146,4 +146,5 @@
 - [evaluate-reverse-polish-notation(计算逆波兰式的值)](./LeetCode/Doc/计算逆波兰式的值.md)
 - [max-points-on-a-line(同一条直线上的最多的点的数量)](./LeetCode/Doc/同一条直线上的最多的点的数量.md)
 - [sort-list(排序List)](./LeetCode/Doc/排序List.md)
+- [insertion-sort-list(使用插入排序对链表进行排序)](./LeetCode/Doc/使用插入排序对链表进行排序.md)
 

From 6feacb0443d7bef23f96130f8efbaacbe9e74489 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Sat, 13 Apr 2019 17:01:29 +0800
Subject: [PATCH 09/24] =?UTF-8?q?=E5=90=8E=E5=BA=8F=E9=81=8D=E5=8E=86?=
 =?UTF-8?q?=E4=BA=8C=E5=8F=89=E6=A0=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...33\350\241\214\346\216\222\345\272\217.md" |   2 +-
 ...06\344\272\214\345\217\211\346\240\221.md" |  59 ++++++++++++
 .../production/LeetCode/six/Solution.class    | Bin 0 -> 2187 bytes
 .../production/LeetCode/six/TreeNode.class    | Bin 0 -> 350 bytes
 LeetCode/src/six/Solution.java                |  88 ++++++++++++++++++
 README.md                                     |   1 +
 6 files changed, 149 insertions(+), 1 deletion(-)
 create mode 100644 "LeetCode/Doc/\345\220\216\345\272\217\351\201\215\345\216\206\344\272\214\345\217\211\346\240\221.md"
 create mode 100644 LeetCode/out/production/LeetCode/six/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/six/TreeNode.class
 create mode 100644 LeetCode/src/six/Solution.java

diff --git "a/LeetCode/Doc/\344\275\277\347\224\250\346\217\222\345\205\245\346\216\222\345\272\217\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\216\222\345\272\217.md" "b/LeetCode/Doc/\344\275\277\347\224\250\346\217\222\345\205\245\346\216\222\345\272\217\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\216\222\345\272\217.md"
index 8f7ed29..d51cac8 100644
--- "a/LeetCode/Doc/\344\275\277\347\224\250\346\217\222\345\205\245\346\216\222\345\272\217\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\216\222\345\272\217.md"
+++ "b/LeetCode/Doc/\344\275\277\347\224\250\346\217\222\345\205\245\346\216\222\345\272\217\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\216\222\345\272\217.md"
@@ -1,6 +1,6 @@
 # insertion-sort-list(使用插入排序对链表进行排序)
 
-<center>知识点：</center>
+<center>知识点：排序，链表</center>
 
 
 ## 题目描述
diff --git "a/LeetCode/Doc/\345\220\216\345\272\217\351\201\215\345\216\206\344\272\214\345\217\211\346\240\221.md" "b/LeetCode/Doc/\345\220\216\345\272\217\351\201\215\345\216\206\344\272\214\345\217\211\346\240\221.md"
new file mode 100644
index 0000000..57f4400
--- /dev/null
+++ "b/LeetCode/Doc/\345\220\216\345\272\217\351\201\215\345\216\206\344\272\214\345\217\211\346\240\221.md"
@@ -0,0 +1,59 @@
+# binary-tree-postorder-traversal（后序遍历二叉树）
+
+<center>知识点：树</center>
+
+
+## 题目描述
+
+Given a binary tree, return the postorder traversal of its nodes' values.
+
+For example:
+Given binary tree{1,#,2,3},
+
+![image-20190413113855000](https://ws2.sinaimg.cn/large/006tNc79gy1g20usuv6s0j308y0860so.jpg)
+
+return[3,2,1].
+
+**Note:** Recursive solution is trivial, could you do it iteratively?
+
+给定一个二叉树，返回其后序遍历结果。
+
+提示：递归解决方案是不值一提的，你选择迭代。
+
+
+## 解题思路
+
+首先明确什么是后序遍历：对于二叉树访问顺序为左-右-根，即为后序遍历。
+
+递归方式很简单，这里说一下迭代的思路，考虑如下二叉树：
+
+![image-20190413125303689](https://ws1.sinaimg.cn/large/006tNc79gy1g20wxyvib7j30n80ggmyz.jpg)
+
+使用栈来解决非递归的后序遍历实现，重点在于以何种顺序入栈，由于是出栈的时候去遍历，所以按照后序遍历的顺序推导出入栈顺序应该是curNode、curNode.right、curNode.left，这样出栈的时候就能保证按照后序遍历的顺序了，另外需要使用一个preNode保存前一个遍历的节点，这样就能确定前一个被遍历的节点是否是当前节点的左/右子节点，如果是，说明其儿子已经被遍历了，这时就可以遍历自己了，否则不能遍历当前节点，需要先将当前节点的子节点入栈，最后的逻辑是：
+
+```
+初始：curNode=null，preNode=null，stack=new Stack()，stack.push(root)
+while(stack不为空)：
+		if curNode==null:
+				curNode=stack.peek()
+		if curNode 是叶子节点：
+				print curNode.val
+				preNode=curNode
+				stack.pop()
+				curNode=null
+		else if preNode是curNode的直接子节点：
+				print curNode.val
+				preNode=curNode
+				stack.pop()
+				curNode=null
+		else：
+				stack.push(curNode.right)
+				stack.push(curNode.left)
+				curNode=curNode.left
+```
+
+
+
+## 代码
+
+[这里](../src/n/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/six/Solution.class b/LeetCode/out/production/LeetCode/six/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..d629a312c2a06464093cf79ac12cb01711cf8e28
GIT binary patch
literal 2187
zcma)7T~ixX7=8}f%_hrI2w!b%wN|8s5=f<AHXu@4+F}D#gGGv{OIX6vkd2#7M{d3G
z!av|R<5g$sMQ^HOgHuMw(U~%%R~>&()#sdSXmG0Iz?}Cz?|Hw@^FAm0+n<kq0&oTu
z6NfNq;G&5ZDc>@oVNz}`$>p+KrVLz(BaW+bxh9us6K~_Xbj?bK8I!hI19K)4GB|-7
zalC_fr9(~@m^bkrZW>q+h>p7@H<%EJ3=G~B&@OqajzD|XEjhE*%@xO=w^xd^bY{K0
zUA$@guH1)4Em(Ie0td1c_tSLFD^>&7D~-{)>{SBKUuCp!-*NnkT@>gaP;T?S<IJ+i
z*kE?UzGJ5uQ%qm<eS0hGRssfVzUKvvq<h{1Z9y2B3+()DfkachGBGx8Hxdc-G@Uo+
zH_E<hK)}dXec6gY@BZ6ul^Zua)|5mQ8Q*`22^Kxs<g-_3ylyPor9yhT6gUOPACt~)
zD$9&rRuFQ~oH6Ig)^l#5WCvBB?PUHBRR2~%+qB&huQagK)Iu)s-BMvpjo9`J99q|N
zjs^4*@fZ!|=}?{t<=If43*~u%SS6ggfSL2Ee%`s_O1iW)*f1i8Y$1sk$f{=p4`<l*
z%(91^h4-;&;TD!Ge1K&EOR}p$1PdRc&%#G?`53l=6$^Q+T5zytp@3ysYds8VG-2Uo
z95dir*uZTIMQmCq!81^{@Ckf@4%LSm*4)a5lPCYQa<#%d#|N5Fte-WQ+vLu{8g6B3
zvm9)xmvl?UI}TaeJrMGIzqeL&)>uUM-NHI$<c@qHVw$Xe)=5YkrsiqYnOl=Xoo-Io
zAQltYtE;5^^O|KZk+N52M-1i@Z@O!4s}eYyJol<>B788em%c%=1f+~(Z_1kmo*ItK
zKiJHg5Du~+@ahEn=Y2!kk!|W)`%^P>Sr#git@}FPBP)*ax9bpp7=Z|cBoWuc+@&c6
zrG9c7;#(>$IKnlmjJ<e~x>a|;OE}7%kPM&~gT)idC~bf2pk;9zk(nK6l=|$@F7)9C
zBBP0no*Jqlx{#{D_zL%v`YtT$v7Zso=t=#1n7cS3W$P}ECiRRqEH~B<Xsh9XjA~zC
zj&J_@C8;UzduR=#dg_+edtv<J|BU}k)p(4ylu~3%Do?{=?pb8D`QZn=mZqTCAXXrD
zF{0K%y_;9>B^XJ<afDF3f<6r5Rg9n?=c!%ANnFPe-(CvK80MQA!RN&J3!K82cnx1;
z6nFW7x{tGXh}ZEWE?^g9c!Eg<_e34i5N?92Dv%oZomKh?c?W*Qah%{JlX!#y)|Z`b
zvvwbJRtNiQ3H^um{8RKF=GhULPtj{&#6bEfS`D1yfA>%#aX68Pvp-3JQGWJLvq!}d
zAtO!NH+B$T)V9%)m5NS<1CK98smw~nppwy~7L%GTwGMfji7Hi{8$+pwFn5q3Q93iR
zWQ_Fa%EZ4zcQRf>PYt~_9F#<iDD+23Kj1R^nL;P75c{jd;2QCqMuy+&DP+0k_&1Lw
zev4f!C=}P~9TVeojE}<(QS9Vg&J!m|;5nk-$2$GYazUY(<{UB##SEu4MlH&-evDHy
fSmPkx;M8NR)UGBFS7^%zQn#d7NnnB%Tkz)Jh{WTt

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/six/TreeNode.class b/LeetCode/out/production/LeetCode/six/TreeNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..b69e80117bb0d9c2f2107b6256e2fcab0159b821
GIT binary patch
literal 350
zcmYjMO-sW-5Pg%Rjfv@3s#WmfvF*WJyeVFULLt;cOYWPvwp-RLq)F-D@*si-e}F$q
zoWvev*?IH%X5RPD=NEumT>5Y@^kC!6#kq?S!QKl^pgF<O@}(qn<DEK0t3t|!d6svC
zR-x7#F0}7euF3~)9M2~S!z0%Ty;$XPQN5<JScz0~CX7ucbRr5>$H$~oZq$w!9SHu?
zR7ECds&4Kqjjl>%@|&&LivT_@0<_R31pn_K^y_-0MZS)n(yh$+B6~bZaLsBQR%i3)
zIktd{lLoy8iG3fZU`qC8u=sIi`T?3=y~BFr$U=v0w_zDDUkDFFj)Bo%H+n}-AAR1!
JN-${V!e5_lJCpzb

literal 0
HcmV?d00001

diff --git a/LeetCode/src/six/Solution.java b/LeetCode/src/six/Solution.java
new file mode 100644
index 0000000..b5b0d4a
--- /dev/null
+++ b/LeetCode/src/six/Solution.java
@@ -0,0 +1,88 @@
+package six;
+
+import java.util.ArrayList;
+import java.util.Stack;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+
+
+class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+
+    TreeNode(int x) {
+        val = x;
+    }
+}
+
+public class Solution {
+    public ArrayList<Integer> postorderTraversal(TreeNode root) {
+        Stack<TreeNode> treeNodeStack = new Stack<>();
+        ArrayList<Integer> arrayList = new ArrayList<>();
+        if (root == null) {
+            return arrayList;
+        }
+
+        TreeNode preNode = null;
+        TreeNode curNode = null;
+
+        treeNodeStack.push(root);
+
+        while (!treeNodeStack.isEmpty()) {
+            if (curNode == null) {
+                curNode = treeNodeStack.peek();
+
+            }
+
+            if (curNode.left == null && curNode.right == null) {
+                preNode = curNode;
+                arrayList.add(curNode.val);
+                treeNodeStack.pop();
+                curNode = null;
+            } else if ((preNode == curNode.left && curNode.left != null) || (preNode == curNode.right && curNode.right != null)) {
+                preNode = curNode;
+                arrayList.add(curNode.val);
+                treeNodeStack.pop();
+                curNode = null;
+            } else {
+                if (curNode.right != null) {
+                    treeNodeStack.push(curNode.right);
+                }
+
+                if (curNode.left != null) {
+                    treeNodeStack.push(curNode.left);
+                }
+                curNode = curNode.left;
+            }
+
+
+        }
+        return arrayList;
+    }
+
+    public static void main(String args[]) {
+        TreeNode root = new TreeNode(1);
+        TreeNode node2 = new TreeNode(2);
+        TreeNode node3 = new TreeNode(3);
+        TreeNode node4 = new TreeNode(4);
+        TreeNode node5 = new TreeNode(5);
+        TreeNode node6 = new TreeNode(6);
+        TreeNode node7 = new TreeNode(7);
+
+        root.left = node2;
+//        root.right = node3;
+//        node2.left = node4;
+//        node2.right = node5;
+//        node3.left = node6;
+//        node3.right = node7;
+
+        Solution solution = new Solution();
+        ArrayList<Integer> arrayList = solution.postorderTraversal(root);
+        System.out.println(arrayList.toArray().toString());
+
+    }
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 58122bf..c7b0fc8 100644
--- a/README.md
+++ b/README.md
@@ -147,4 +147,5 @@
 - [max-points-on-a-line(同一条直线上的最多的点的数量)](./LeetCode/Doc/同一条直线上的最多的点的数量.md)
 - [sort-list(排序List)](./LeetCode/Doc/排序List.md)
 - [insertion-sort-list(使用插入排序对链表进行排序)](./LeetCode/Doc/使用插入排序对链表进行排序.md)
+- [binary-tree-postorder-traversal（后序遍历二叉树）](./LeetCode/Doc/后序遍历二叉树.md)
 

From 20c3d5c67eb106f342cd7c1353721852b474e3b6 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Sat, 13 Apr 2019 17:03:08 +0800
Subject: [PATCH 10/24] =?UTF-8?q?=E5=90=8E=E5=BA=8F=E9=81=8D=E5=8E=86?=
 =?UTF-8?q?=E4=BA=8C=E5=8F=89=E6=A0=91-update-readme?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...\201\215\345\216\206\344\272\214\345\217\211\346\240\221.md" | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git "a/LeetCode/Doc/\345\220\216\345\272\217\351\201\215\345\216\206\344\272\214\345\217\211\346\240\221.md" "b/LeetCode/Doc/\345\220\216\345\272\217\351\201\215\345\216\206\344\272\214\345\217\211\346\240\221.md"
index 57f4400..3f7cca5 100644
--- "a/LeetCode/Doc/\345\220\216\345\272\217\351\201\215\345\216\206\344\272\214\345\217\211\346\240\221.md"
+++ "b/LeetCode/Doc/\345\220\216\345\272\217\351\201\215\345\216\206\344\272\214\345\217\211\346\240\221.md"
@@ -56,4 +56,4 @@ while(stack不为空)：
 
 ## 代码
 
-[这里](../src/n/Solution.java)
\ No newline at end of file
+[这里](../src/six/Solution.java)
\ No newline at end of file

From 91f0df8a44787f52719f879ff3c128e3d4ae825e Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Sat, 13 Apr 2019 17:27:49 +0800
Subject: [PATCH 11/24] =?UTF-8?q?=E4=BA=8C=E5=8F=89=E6=A0=91=E7=9A=84?=
 =?UTF-8?q?=E5=85=88=E5=BA=8F=E9=81=8D=E5=8E=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...06\344\272\214\345\217\211\346\240\221.md" |  37 ++++++++
 .../production/LeetCode/seven/Solution.class  | Bin 0 -> 2077 bytes
 .../production/LeetCode/seven/TreeNode.class  | Bin 0 -> 354 bytes
 LeetCode/src/seven/Solution.java              |  83 ++++++++++++++++++
 4 files changed, 120 insertions(+)
 create mode 100644 "LeetCode/Doc/\345\205\210\345\272\217\351\201\215\345\216\206\344\272\214\345\217\211\346\240\221.md"
 create mode 100644 LeetCode/out/production/LeetCode/seven/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/seven/TreeNode.class
 create mode 100644 LeetCode/src/seven/Solution.java

diff --git "a/LeetCode/Doc/\345\205\210\345\272\217\351\201\215\345\216\206\344\272\214\345\217\211\346\240\221.md" "b/LeetCode/Doc/\345\205\210\345\272\217\351\201\215\345\216\206\344\272\214\345\217\211\346\240\221.md"
new file mode 100644
index 0000000..ffc4650
--- /dev/null
+++ "b/LeetCode/Doc/\345\205\210\345\272\217\351\201\215\345\216\206\344\272\214\345\217\211\346\240\221.md"
@@ -0,0 +1,37 @@
+# binary-tree-preorder-traversal（先序遍历二叉树）
+
+<center>知识点：树</center>
+
+
+## 题目描述
+
+Given a binary tree, return the postorder traversal of its nodes' values.
+
+For example:
+Given binary tree{1,#,2,3},
+
+![image-20190413113855000](https://ws2.sinaimg.cn/large/006tNc79gy1g20usuv6s0j308y0860so.jpg)
+
+return[1,2,3].
+
+Note: Recursive solution is trivial, could you do it iteratively?
+
+
+给定一个二叉树，返回其先序遍历结果。
+
+提示：递归解决方案是不值一提的，你选择迭代。
+
+
+## 解题思路
+
+首先明确什么是先序遍历：对于二叉树访问顺序为根-左-右，即为先序遍历。
+
+递归方式很简单，这里说一下迭代的思路，考虑如下二叉树：
+
+![image-20190413125303689](https://ws1.sinaimg.cn/large/006tNc79gy1g20wxyvib7j30n80ggmyz.jpg)
+使用栈，入栈顺序为根、左，右。
+
+
+## 代码
+
+[这里](../src/seven/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/seven/Solution.class b/LeetCode/out/production/LeetCode/seven/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..4c2d4e612db23cabfac0b4243bd59c3e073c38de
GIT binary patch
literal 2077
zcma)7T~ixX7=D&)vPoRhl=9J7TP<xNA%P&JttOa4DQ&6YLxUj2uO%#DX_C!sHq4+u
zz!|T4;f3Rc<DIwFslgG)alB|}{7Zg5XR`?l))^-==e*~<-_QG;>~DYl_%nb>m|+Yc
zr{HE7U1FaOLq;wH6*FPn!mK#n7P>jH+!4!N1^0x(yjbpsxxA?$A4U{8u`GnJh$Z2-
zEMmVE#@i?;SdkEzGOC81li-UdRwc-@=9VtuRNkoSi;c>rZmnpWW#07U&7xLb)ht7t
z-AmctG3pYc`MSQRSJMTv+^`L^nw4<6X6dH2MR!Zv)2+HzmM|Q5?N%&ZUu2$aBEPHc
zX=yr@(=(Q(?dOfUO>fyUP5UTr$6kWJZfnJdjPLO*h%0)9v~~yyeIC6xvQlhVBDIA6
z;|=ZC+D%>ZxH_SyPL`cxvJsC}C&5(fvaD50>G`Uymvk#DjJusU3tG*=jf3S(IWU%7
zFiKU;Zdfd6>i@y>UpeH8W>nc$e8W>j!M2QQDeFvDvr3%RndhhpYn7NxxcgOipLF+Y
z?tb0fZ%7E%-BC*j7tDrL)bALACEaZbjETXjIExs`bTniK2NrR3)4@)~J6Kh)rs7?!
zt9XD774PAF6(8V36(2#95NXk@O$Qa57*tUd%UNu7^z9l{yo^^A=qk2RQn3R=#V#Hy
zD66P|SVf&OoM|m>?&?KS&bKF+D$SE&M@n~;5)^71`qH+5dEO=Ov0*cSw#7>N;+`S2
zVrLT%NbFjpz9V7idFp?A5O2Lwv-h3HNpD}xtV!sNdo#PiX=)jz9d;m>^=+}SK)z>B
zi-rBVtydVuY*6n$5W`F_lOi^WqH7gWRk2NHB%+6emn)q_LECK6>SQS{+1leh9-5JB
zB2k&RA48`@QC#F7)d2qh0Usnm9j-6(l;$pR_m3Pv`j$c$&T$PmmodCVS#25MJTCAg
ziNVu~&eA8`{k;475MApB@GTrd=I&oiK7)VsaWW&1CZ8bi1C%C$YpG-tp|w;K;V)sv
z<Y&lHe&H9W8963DLHAP(k2-?K#W@Q%N65(E{QavW)}O>V@)YMCkH`s+NZTVKY#)t2
zW{tAb*DCrbpF@zHMcGj=d+Ns^;kbk=xQrx*Fo9v*KpfLZ;2uW!WRiRgDU>k=6XUS(
zDn6#wXSj;bY55g04o;ITEL@z33PB$vUO{}p=$DCA6pxr?h$D#MQ)U@tRdLqSPhHC@
z(Xkq#Rg$^^1pY+7f|P>MKhUdS>~~E2FNQcdF|2WfSk45~h=HW&6z2WzA=GvGfS(#6
z_$hES>Uw~}q7W1c8Cgg{A^C+A71~U|5gomfOnr~YA)*}V=}a&d<otRvq3>`e7HXom
ziM}TK1!a5=v=bx>aFg{+qX#p*yTxW_S?6s6G{@gv+~=3FfF*2T83sR-f?nILiV5Z<
zPa$Y7Y&``28X*#dT*7rqKE|6P-~zTZvUrV>pRvdBI;8-0S9ltP!W;wCUm&O(IORYd
Ua)1_8ZrzM96F&>g*o8O#0TQ9k`Tzg`

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/seven/TreeNode.class b/LeetCode/out/production/LeetCode/seven/TreeNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..93e9323bef38dce633ae043684de1c560ae3d703
GIT binary patch
literal 354
zcmY*UO-sW-5Ph4Zjfv@pwXK2|k8Ka;;!W`)6bhjpT5{jSwcWBNkfy=E<v|1w{s4cJ
z_!4@NW#`Suo0&I1zhB<~ZgJ_u!MO(;Ll+|#V*$I8MnEhC9HU-Jfqt}CmCC|(q0};e
zR(AreLT|P#weNMN%Lh^?i)l=FWL=;a=}avTuZb$wGBL~yqCAx*mW8h4W6~+Nde2pF
z0{$vL6sel)n%r6C=1}T9yV=P~2JmqapoO+T_rDTqs~Mq@*(Q8Sb}FSNdoqo2&5Imf
zX!Em^7I1OWpx2<F@8c8#0lhgaK4xa05VNZfSnrH1bZEQHlp*Jh;9<-dv<(}*<4hlY
LZs9FBYx)L%h{ioT

literal 0
HcmV?d00001

diff --git a/LeetCode/src/seven/Solution.java b/LeetCode/src/seven/Solution.java
new file mode 100644
index 0000000..9cfce3a
--- /dev/null
+++ b/LeetCode/src/seven/Solution.java
@@ -0,0 +1,83 @@
+package seven;
+
+/**
+ * @author dmrfcoder
+ * @date 2019-04-13
+ */
+
+import java.util.ArrayList;
+import java.util.Stack;
+
+/**
+ * Definition for binary tree
+ */
+
+class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+
+    TreeNode(int x) {
+        val = x;
+    }
+}
+
+public class Solution {
+    public ArrayList<Integer> preorderTraversal(TreeNode root) {
+        Stack<TreeNode> stack = new Stack<>();
+        ArrayList<Integer> arrayList = new ArrayList<>();
+        if (root == null) {
+            return arrayList;
+        }
+
+
+        TreeNode curNode = root;
+        arrayList.add(root.val);
+        stack.push(root);
+
+        while (!stack.empty()) {
+            if (curNode == null) {
+                curNode = stack.pop();
+                if (curNode.right != null) {
+                    arrayList.add(curNode.right.val);
+                    stack.push(curNode.right);
+                    curNode = curNode.right;
+                } else {
+                    curNode = null;
+                }
+                continue;
+            } else if (curNode.left != null) {
+                arrayList.add(curNode.left.val);
+                stack.push(curNode.left);
+
+
+            }
+            curNode = curNode.left;
+        }
+
+        return arrayList;
+
+    }
+
+    public static void main(String args[]) {
+        TreeNode root = new TreeNode(1);
+        TreeNode node2 = new TreeNode(2);
+        TreeNode node3 = new TreeNode(3);
+        TreeNode node4 = new TreeNode(4);
+        TreeNode node5 = new TreeNode(5);
+        TreeNode node6 = new TreeNode(6);
+        TreeNode node7 = new TreeNode(7);
+
+        root.left = node2;
+//        root.right = node3;
+//        node2.left = node4;
+//        node2.right = node5;
+//        node3.left = node6;
+//        node3.right = node7;
+
+        Solution solution = new Solution();
+        ArrayList<Integer> arrayList = solution.preorderTraversal(root);
+        System.out.println(arrayList.toArray().toString());
+
+    }
+}
\ No newline at end of file

From 98a7004bbb28d9062954b94c13ad3cb98640521d Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Sat, 13 Apr 2019 17:29:53 +0800
Subject: [PATCH 12/24] =?UTF-8?q?=E4=BA=8C=E5=8F=89=E6=A0=91=E7=9A=84?=
 =?UTF-8?q?=E5=85=88=E5=BA=8F=E9=81=8D=E5=8E=86-update-readme?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index c7b0fc8..353f109 100644
--- a/README.md
+++ b/README.md
@@ -148,4 +148,5 @@
 - [sort-list(排序List)](./LeetCode/Doc/排序List.md)
 - [insertion-sort-list(使用插入排序对链表进行排序)](./LeetCode/Doc/使用插入排序对链表进行排序.md)
 - [binary-tree-postorder-traversal（后序遍历二叉树）](./LeetCode/Doc/后序遍历二叉树.md)
+- [binary-tree-preorder-traversal（先序遍历二叉树）](./LeetCode/Doc/先序遍历二叉树.md)
 

From e4c5165c9d4071cd9dc55ad176e9065c9a971b31 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Sun, 14 Apr 2019 12:47:28 +0800
Subject: [PATCH 13/24] =?UTF-8?q?=E9=93=BE=E8=A1=A8=E9=87=8D=E6=8E=92?=
 =?UTF-8?q?=E5=BA=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...50\351\207\215\346\216\222\345\272\217.md" |  34 ++++++++
 .../production/LeetCode/eight/ListNode.class  | Bin 0 -> 357 bytes
 .../production/LeetCode/eight/Solution.class  | Bin 0 -> 1252 bytes
 LeetCode/src/eight/Solution.java              |  76 ++++++++++++++++++
 README.md                                     |   1 +
 5 files changed, 111 insertions(+)
 create mode 100644 "LeetCode/Doc/\351\223\276\350\241\250\351\207\215\346\216\222\345\272\217.md"
 create mode 100644 LeetCode/out/production/LeetCode/eight/ListNode.class
 create mode 100644 LeetCode/out/production/LeetCode/eight/Solution.class
 create mode 100644 LeetCode/src/eight/Solution.java

diff --git "a/LeetCode/Doc/\351\223\276\350\241\250\351\207\215\346\216\222\345\272\217.md" "b/LeetCode/Doc/\351\223\276\350\241\250\351\207\215\346\216\222\345\272\217.md"
new file mode 100644
index 0000000..3f216b0
--- /dev/null
+++ "b/LeetCode/Doc/\351\223\276\350\241\250\351\207\215\346\216\222\345\272\217.md"
@@ -0,0 +1,34 @@
+# reorder-list（链表重排序）
+
+<center>知识点：链表</center>
+
+
+## 题目描述
+
+Given a singly linked list$ L: L_0→L_1→…→L{n-1}→L_n​$,
+reorder it to: $L_0→L_n →L_1→L_{n-1}→L_2→L_{n-2}→…​$
+
+You must do this in-place without altering the nodes' values.
+
+For example,
+Given{1,2,3,4}, reorder it to{1,4,2,3}.
+
+给定一个链表$ L: L_0→L_1→…→L{n-1}→L_n$,
+将其重排序为： $L_0→L_n →L_1→L_{n-1}→L_2→L_{n-2}→…​$
+你必须在不改变节点值的情况下完成。
+比如：
+给定{1,2,3,4},重排序为：{1,4,2,3}
+
+## 解题思路
+
+比如：$ L: L_0→L_1→…→L{n-1}→L_n​$，首先利用快慢指针将该链表分为两个部分：
+
+$L_a:L_0→L_1→…L_{\frac{n}{2}}$,
+
+$L_b:L_{\frac{n}{2}+1}→L_{\frac{n}{2}+2}→…L_{n}$
+
+然后将$L_b$翻转，然后合并$L_a$和$L_b$即可。
+
+## 代码
+
+[这里](../src/eight/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/eight/ListNode.class b/LeetCode/out/production/LeetCode/eight/ListNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..332128c337edc6e4434108dcb0ee908495a1c677
GIT binary patch
literal 357
zcmY*UO;5r=6r61fm0C)ziW)B-fdjpG(|9p4A!*=%>3v%_u%xz0X$gPJ12OU75Aa7B
zXQLMnZ{F^_nfLMa{qYIl7FQlRIPJl~nSpZ`Ll+kU_D&W8VkY2}YTpQiiPEce6DNAx
z%&Ql5C(ymurEVT58O_Ei(<6C-L841FZ(lQ2Kg+Bj6D3tHi&WOy{QpR&S?euF>;=4K
z)z-Os(nj20Rz=(Bs+?}*PWte0>7xtR#}Rr0!T&Y5n32VWELZU&+o+to+M{ub8=lkQ
zjTVD;B1{LOV0buY_W4>+VKjruJH+Jr0Ba%+u-`~o=o2G0Vwo7yeu98ZKxX)BW5qNz
NijZS?5jDme{Q!)CJaGU3

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/eight/Solution.class b/LeetCode/out/production/LeetCode/eight/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..841bad0265b24f7cc740f453bb1d1f48c672bc56
GIT binary patch
literal 1252
zcmZuwT~8BH5Iwi-c4;Y}6|e#d%16t#R6ZoJ7*S9JZA%Q;grG4?SzxiWWZ9|@JQ;m3
z#>9yKfoBtyL=qo)@CWz<OicU}isx>(;)6+Z=gi!>GiT0hzyALG1;7|af~Z9-fEo;H
z(1Wyb4T&IB#N;ugAt~U$Vihgtsz6ONmJ?8>ORJ_pW7;a3+49zkX)hWp1x8xZrMywd
z8MY;TFQ_;h){a0^+O*a;oa92OP<E_RaYCTZHcR%ZX{W6nM<5*aGNhYjhY8uM)-kuX
zrFT-{@4Y~vdOQ3N9wEauLzYx_3Z*9k+O}<0N(78G$FwV0*)WY&f%*l<$Un*$+b&&d
z!14KV%dm<9ZPDfQrt#QF7L4M0a>22!;<`&qG3<2?75>k)fLbJ9vT*IFXU9Byi8JkZ
z8VCdzN@Y85&R9~u`l>cVvS$bZ1Vgxpus}mayXxffiW7U$>Z=f%&`g<52+yx<nt7>1
z(R?aRbS{=d57%1D-GjTPY6$YIqnD%=wCdmi#CrlCLOlI$uod;hp-KW8&`6K1(9DyM
z#U8U|(Rcb0-s&IVJHjh{DVvGAuuB>jg*}u>(9P~2f0s6;B*aJfB8tRnL~$MU2%QmC
zM*I=R<h`0wBL0-RfBYk&96@KR0ojTP?n_Otq%lcmYce~%fBa3(Qsd6Dg44w9WE|lH
z9q2|UqUfT=Js8J%OyB~h(2H60BZC1f@^%?9Jj5XK(6NRglqgi0FLp7EXBfdtjN&!_
zNN-qSj}@d&_bKZlJG3B7{mSfg%0;`htwb8{o}-P(M=f8FQJ4(J@qqloP{`pf8HTwi
zD(a~%(HX`BtARY#Uue|O$zS&`v{z8qG2-xP=%UM{0M6oEWkLAK1{!0zL)0uO2T;-y
zs00}a`~+DEG=h{OQLRL(9;cS^1dl{jU6sxu)TIOXDZO9+1nuN=8F7W4WbbPn|2oM|
zp%2p(?IuN<!DZaSBn6(q9OiKw_i)FRY_`IVE9r5WXS`usaD$7HLUp+7kwW!R`d(M4
WB$w3Z3N_F7{ghRHt^=&#L-Y@h65~Ap

literal 0
HcmV?d00001

diff --git a/LeetCode/src/eight/Solution.java b/LeetCode/src/eight/Solution.java
new file mode 100644
index 0000000..ec55f31
--- /dev/null
+++ b/LeetCode/src/eight/Solution.java
@@ -0,0 +1,76 @@
+package eight;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+
+/**
+ * Definition for singly-linked list.
+ */
+class ListNode {
+    int val;
+    ListNode next;
+
+    ListNode(int x) {
+        val = x;
+        next = null;
+    }
+}
+
+public class Solution {
+    public void reorderList(ListNode head) {
+        if (head != null && head.next != null) {
+            ListNode fast, slow;
+            fast = slow = head;
+            //快慢指针找出链表的中间节点
+            while (fast.next != null && fast.next.next != null) {
+                fast = fast.next.next;
+                slow = slow.next;
+            }
+
+            //拆分链表
+            ListNode preNode = slow.next;
+            slow.next = null;
+            ListNode afterNode = preNode.next;
+            preNode.next=null;
+            //翻转后一半链表
+            while (afterNode != null) {
+                ListNode tempNode = afterNode.next;
+                afterNode.next = preNode;
+                preNode = afterNode;
+                afterNode = tempNode;
+            }
+
+            //合并链表
+            while (preNode != null && head != null) {
+                ListNode tempNode1 = head.next;
+                ListNode tempNode2 = preNode.next;
+                head.next = preNode;
+                preNode.next = tempNode1;
+                preNode = tempNode2;
+                head = tempNode1;
+
+            }
+
+
+        }
+
+    }
+
+
+    public static void main(String[] args) {
+        ListNode head = new ListNode(1);
+        ListNode node2 = new ListNode(2);
+        ListNode node3 = new ListNode(3);
+        ListNode node4 = new ListNode(4);
+        ListNode node5 = new ListNode(5);
+
+        head.next = node2;
+        node2.next = node3;
+        node3.next = node4;
+        node4.next = node5;
+        Solution solution = new Solution();
+        solution.reorderList(head);
+    }
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 353f109..e91e45d 100644
--- a/README.md
+++ b/README.md
@@ -149,4 +149,5 @@
 - [insertion-sort-list(使用插入排序对链表进行排序)](./LeetCode/Doc/使用插入排序对链表进行排序.md)
 - [binary-tree-postorder-traversal（后序遍历二叉树）](./LeetCode/Doc/后序遍历二叉树.md)
 - [binary-tree-preorder-traversal（先序遍历二叉树）](./LeetCode/Doc/先序遍历二叉树.md)
+- [reorder-list（链表重排序）](./LeetCode/Doc/链表重排序.md)
 

From a65e6a625397b6378fd3e15b2fb9e7da5d46cdd5 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Sun, 14 Apr 2019 13:36:09 +0800
Subject: [PATCH 14/24] =?UTF-8?q?=E6=89=BE=E5=87=BA=E9=93=BE=E8=A1=A8?=
 =?UTF-8?q?=E4=B8=AD=E7=8E=AF=E7=9A=84=E5=85=A5=E5=8F=A3=E8=8A=82=E7=82=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...45\345\217\243\350\212\202\347\202\271.md" |  41 +++++++++++
 .../production/LeetCode/nine/ListNode.class   | Bin 0 -> 355 bytes
 .../production/LeetCode/nine/Solution.class   | Bin 0 -> 1095 bytes
 LeetCode/src/nine/Solution.java               |  65 ++++++++++++++++++
 README.md                                     |   1 +
 5 files changed, 107 insertions(+)
 create mode 100644 "LeetCode/Doc/\346\211\276\345\207\272\351\223\276\350\241\250\344\270\255\347\216\257\347\232\204\345\205\245\345\217\243\350\212\202\347\202\271.md"
 create mode 100644 LeetCode/out/production/LeetCode/nine/ListNode.class
 create mode 100644 LeetCode/out/production/LeetCode/nine/Solution.class
 create mode 100644 LeetCode/src/nine/Solution.java

diff --git "a/LeetCode/Doc/\346\211\276\345\207\272\351\223\276\350\241\250\344\270\255\347\216\257\347\232\204\345\205\245\345\217\243\350\212\202\347\202\271.md" "b/LeetCode/Doc/\346\211\276\345\207\272\351\223\276\350\241\250\344\270\255\347\216\257\347\232\204\345\205\245\345\217\243\350\212\202\347\202\271.md"
new file mode 100644
index 0000000..237a744
--- /dev/null
+++ "b/LeetCode/Doc/\346\211\276\345\207\272\351\223\276\350\241\250\344\270\255\347\216\257\347\232\204\345\205\245\345\217\243\350\212\202\347\202\271.md"
@@ -0,0 +1,41 @@
+# linked-list-cycle-ii(找出链表中环的入口节点)
+
+<center>知识点：链表</center>
+
+
+## 题目描述
+Given a linked list, return the node where the cycle begins. If there is no cycle, returnnull.
+
+Follow up:
+Can you solve it without using extra space?
+
+
+给定一个链表，返回其中环的入口节点，如果没有环，返回null
+提示：尽量不要使用额外空间。
+
+
+## 解题思路
+
+参考：https://www.nowcoder.com/questionTerminal/6e630519bf86480296d0f1c868d425ad
+
+思路： 
+
+  1）使用快慢指针方法，判定是否存在环，并记录两指针相遇位置(Z)； 
+
+  2）将两指针分别放在链表头(X)和相遇位置(Z)，并改为相同速度推进，则两指针在环开始位置相遇(Y)。 
+
+  证明如下： 
+
+  如下图所示，X,Y,Z分别为链表起始位置，环开始位置和两指针相遇位置，则根据快指针速度为慢指针速度的两倍，当两指针相遇时快指针一定比慢指针多走了n圈，可以得出： 
+
+  $2*(a + b) = a + b + n * (b + c)$；
+
+即   $a=(n - 1) * b + n * c = (n - 1)(b + c) +c​$; 
+
+![122270_1439340467801_QQ截图20150812084712](https://ws3.sinaimg.cn/large/006tNc79gy1g2238ac663j30ai05a3z0.jpg)
+
+ 注意到b+c恰好为环的长度，这时如果可以再让快指针走c步（只要是整数圈多c部即可）即可找出入口点了，所以我们再用两个指针，第一个指针p1指向起点X，第二个指针p2指向刚才相遇的点Z，然后让p1和p2一次走一步，当p1走了a步也就是$(n - 1)(b + c) +c$步时，p2也走了$(n - 1)(b + c) +c$步，注意p2起点距离圆的入口点多了b步，那么此时p2应该相对于圆的入口点走了$(n-1)(b+c)+c+b=n(b+c)$步，也就是到了圆的入口点，而p1走了a步自然也到了圆的入口点，所以此时p1与p2会相遇，那么反向推倒，当p1与p2相遇时刚好就在圆的入口点。
+
+## 代码
+
+[这里](../src/nine/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/nine/ListNode.class b/LeetCode/out/production/LeetCode/nine/ListNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..05f6cb46d57d844f95f2a57daad071b7f6fa5b8a
GIT binary patch
literal 355
zcmY+9F;BxV5QU$Uw4os-C4~ZFVQf2)g$=}lgj6YNhobCGu)tMtq%^7ew-_oU27UlP
z3h@jq4EN4HfA@U%`Stz*;0k8}IvDog;mFFdkCBfP0e2%y0WlNsjM_E=QEIeNNvhY)
zyn0mE0^J*JbaP8$Jey=pcdT2G+`N6sRsA6Il9f2E3Rz~d*7p8a^qObA<_}weU|F?w
zq3*SX`^&0q8(o>pmE6b>0Zv17;fL5mkI(<65Exi0DW!Qz7WqmQoYWmpGF)((4mWfd
z?54sRPz58vK6A*^f`nzF=^MoKd<SPLc5q)=a?q#7Gy(?HL$=2_z>ooqe%lcJn9_iZ
KPg6n8_Qv0t_&cQl

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/nine/Solution.class b/LeetCode/out/production/LeetCode/nine/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..8fc25b12d4e08020bbdf641738e5dad212d9cb04
GIT binary patch
literal 1095
zcmZuw?M@R>5IwiscImPe<f9f*J`1+ArGm&;QDcZCCT%s=V2H-Jlob}+EorwX52XG@
zgOEt#PfUCYAHY{oJa@MRH73o>+&gDx&Y8Xa_UrQ(05e$7(2iIL3dU57YxLJt#5DvE
zlO_?u1d=kH(vZfaii|*T$+9iywtx~(tP1#-s~e_3N6xa%LZh;7)*c({W!`k<swJbm
zYSb)wZeIGGEvqikHsP6KwcK#5s+|>R-!L7s<Sg%%WbIJg1LUl_Q(*sW;-53;Zkfi$
zS*J4~6EBUrLsu_XUkikbj!}A*H+EbC6v<4*uxx=y{Aq66*fla`!`{pkotkBDW?e-_
zZIc|k|C1I7*rYQp&{l79=N@V%;aaiUsFlnWOY#r5lugPBI&_3}Tt|c%S9puA%uKZ|
zTQxem(W7Eo#|_NrxQSU6b2{cFvh$qrgY|7LjB;%Ajdbz*lKdZl;$Gb`E96&gFyHHm
zwW^tiRO(Q#X;ip)W!ESRi2D@m_Wm0npzcU`*~Ty*L_1#%_#A{(M0<g!485QaOdLUc
zVBkXsZP2}ppp&ug0dNsrJaH0wXl3y!(SG_D$*%~A{p4C9pE`i=1S8V9QM4K5(>xYZ
z>365!-$U_G;bzV&&ZkZgO`o7g-k!sMr1r%=XDBYO6|w-LoZ3f@SD@i4`Z0h}3?hyp
zKJ#IIsWIHeIF^yXJ^lsqNa7Jvc*5*6OyW7FTwN0$_ognYKrbRxrePJA82J!lO_Y(s
zX&_Dw{)D39GJj*8LPQDZCkbyEZwU(!Hg^nV&3^=cP6h!6`DE%7e5oYOF#>Bx2o}=G
zL#T`Xk7(=jA0TuH?R@tmXp?Q&e4ZO$AeTiB$s&d&D!GMO+;REOc;mQ%0pdec=JD^M
a{y~?2jNfXAJrvgI+)RXu1xASWVe~f<;LutC

literal 0
HcmV?d00001

diff --git a/LeetCode/src/nine/Solution.java b/LeetCode/src/nine/Solution.java
new file mode 100644
index 0000000..7d7afc1
--- /dev/null
+++ b/LeetCode/src/nine/Solution.java
@@ -0,0 +1,65 @@
+package nine;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+
+/**
+ * Definition for singly-linked list.
+ */
+
+class ListNode {
+    int val;
+    ListNode next;
+
+    ListNode(int x) {
+        val = x;
+        next = null;
+    }
+}
+
+public class Solution {
+    public ListNode detectCycle(ListNode head) {
+        if (head == null) {
+            return null;
+        }
+        ListNode fast, slow;
+        fast = slow = head;
+        while (fast.next != null && fast.next.next != null) {
+            fast = fast.next.next;
+            slow = slow.next;
+            if (fast == slow) {
+                break;
+            }
+        }
+
+        if (fast.next == null || fast.next.next == null) {
+            return null;
+        }
+
+        fast = head;
+        while (fast != null && slow != null) {
+            if (fast == slow) {
+                return fast;
+            }
+            fast = fast.next;
+            slow = slow.next;
+
+        }
+        return null;
+
+
+    }
+
+    public static void main(String[] args){
+        ListNode head=new ListNode(1);
+        ListNode node2=new ListNode(2);
+        head.next=node2;
+        node2.next=head;
+        Solution solution=new Solution();
+        ListNode res=solution.detectCycle(head);
+        System.out.println(res.val);
+
+    }
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index e91e45d..6b25513 100644
--- a/README.md
+++ b/README.md
@@ -150,4 +150,5 @@
 - [binary-tree-postorder-traversal（后序遍历二叉树）](./LeetCode/Doc/后序遍历二叉树.md)
 - [binary-tree-preorder-traversal（先序遍历二叉树）](./LeetCode/Doc/先序遍历二叉树.md)
 - [reorder-list（链表重排序）](./LeetCode/Doc/链表重排序.md)
+- [linked-list-cycle-ii(找出链表中环的入口节点)](./LeetCode/Doc/找出链表中环的入口节点.md)
 

From bc06ec0dc7dec814b94e98aff785aa7c888ff882 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Sun, 14 Apr 2019 13:54:12 +0800
Subject: [PATCH 15/24] =?UTF-8?q?=E5=88=A4=E6=96=AD=E9=93=BE=E8=A1=A8?=
 =?UTF-8?q?=E4=B8=AD=E6=98=AF=E5=90=A6=E6=9C=89=E7=8E=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...46\345\255\230\345\234\250\347\216\257.md" | 25 ++++++++++++
 LeetCode/src/ten/Solution.java                | 40 +++++++++++++++++++
 README.md                                     |  1 +
 3 files changed, 66 insertions(+)
 create mode 100644 "LeetCode/Doc/\345\210\244\346\226\255\351\223\276\350\241\250\344\270\255\346\230\257\345\220\246\345\255\230\345\234\250\347\216\257.md"
 create mode 100644 LeetCode/src/ten/Solution.java

diff --git "a/LeetCode/Doc/\345\210\244\346\226\255\351\223\276\350\241\250\344\270\255\346\230\257\345\220\246\345\255\230\345\234\250\347\216\257.md" "b/LeetCode/Doc/\345\210\244\346\226\255\351\223\276\350\241\250\344\270\255\346\230\257\345\220\246\345\255\230\345\234\250\347\216\257.md"
new file mode 100644
index 0000000..9ca82a9
--- /dev/null
+++ "b/LeetCode/Doc/\345\210\244\346\226\255\351\223\276\350\241\250\344\270\255\346\230\257\345\220\246\345\255\230\345\234\250\347\216\257.md"
@@ -0,0 +1,25 @@
+# linked-list-cycle(判断链表中是否存在环)
+
+<center>知识点：链表</center>
+
+
+## 题目描述
+
+Given a linked list, determine if it has a cycle in it.
+
+Follow up:
+Can you solve it without using extra space?
+
+给定一个链表，判断其中是否存在环。
+
+额外要求：
+尽量不要使用额外空间
+
+
+## 解题思路
+
+使用快慢指针即可。
+
+## 代码
+
+[这里](../src/ten/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/src/ten/Solution.java b/LeetCode/src/ten/Solution.java
new file mode 100644
index 0000000..62262f5
--- /dev/null
+++ b/LeetCode/src/ten/Solution.java
@@ -0,0 +1,40 @@
+package ten;
+
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+
+class ListNode {
+    int val;
+    ListNode next;
+
+    ListNode(int x) {
+        val = x;
+        next = null;
+    }
+}
+
+public class Solution {
+
+    public boolean hasCycle(ListNode head) {
+
+        if (head == null) {
+            return false;
+        }
+        ListNode fast, slow;
+        fast = slow = head;
+
+        while (fast.next != null && fast.next.next != null) {
+            fast = fast.next.next;
+            slow = slow.next;
+            if (fast == slow) {
+                return true;
+            }
+        }
+        return false;
+
+
+    }
+}
diff --git a/README.md b/README.md
index 6b25513..c818074 100644
--- a/README.md
+++ b/README.md
@@ -151,4 +151,5 @@
 - [binary-tree-preorder-traversal（先序遍历二叉树）](./LeetCode/Doc/先序遍历二叉树.md)
 - [reorder-list（链表重排序）](./LeetCode/Doc/链表重排序.md)
 - [linked-list-cycle-ii(找出链表中环的入口节点)](./LeetCode/Doc/找出链表中环的入口节点.md)
+- [linked-list-cycle(判断链表中是否存在环)](./LeetCode/Doc/判断链表中是否存在环.md)
 

From 8c067c9f14e7656aabdaec8a44dca85542fa129c Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Mon, 15 Apr 2019 16:58:16 +0800
Subject: [PATCH 16/24] =?UTF-8?q?=E5=8D=95=E8=AF=8D=E5=88=87=E5=88=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...25\350\257\215\345\210\207\345\210\206.md" |  42 +++++++++++++++++
 .../production/LeetCode/eleven/Solution.class | Bin 0 -> 1671 bytes
 .../production/LeetCode/nine/Solution.class   | Bin 1095 -> 1099 bytes
 .../production/LeetCode/ten/ListNode.class    | Bin 0 -> 353 bytes
 .../production/LeetCode/ten/Solution.class    | Bin 0 -> 566 bytes
 LeetCode/src/eleven/Solution.java             |  43 ++++++++++++++++++
 README.md                                     |   1 +
 7 files changed, 86 insertions(+)
 create mode 100644 "LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\206.md"
 create mode 100644 LeetCode/out/production/LeetCode/eleven/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/ten/ListNode.class
 create mode 100644 LeetCode/out/production/LeetCode/ten/Solution.class
 create mode 100644 LeetCode/src/eleven/Solution.java

diff --git "a/LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\206.md" "b/LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\206.md"
new file mode 100644
index 0000000..21d60e8
--- /dev/null
+++ "b/LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\206.md"
@@ -0,0 +1,42 @@
+# word-break（单词切分）
+
+<center>知识点：动态规划</center>
+
+
+## 题目描述
+
+Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words.
+
+For example, given
+s ="leetcode",
+dict =["leet", "code"].
+
+Return true because"leetcode"can be segmented as"leet code".
+
+-----
+
+给定一个字符串s和一个词典，判断s是否可以被切割成一个或者多个词典中的单词。
+
+比如，给定s="leetcode"，dict=["leet","code"]，应该返回true，因为"leetcode"可以被切分成"leet"和"code"两个片段。
+
+## 解题思路
+
+使用动态规划，假设$f(j)$的真值表示$s[0,j]$是否可以被分词，则：
+$f(n)=f(i)\&\&f(i+1,n)$
+那么如果我们要求$f(n)$是否可以被分词，我们首先需要求出$f(i)$，然后再对$s[i+1,n]$的字符串判断是否可以分词，要求$f(i)$，又要让$j$从0开始到$i-1$，判断$f(j)$为真且$f(j，i)$为真…
+
+伪代码如下：
+
+```
+假设s的长度为length，使用array[length+1]代表f(i)到f（n）的真值，则：
+初始array[0]=true：
+for i in 0 to length:
+		for j in 0 to i:
+				if array[j]&&dict.contains(s[j:i]):
+						array[i]=true;
+return array[length]
+```
+
+## 代码
+
+[这里](../src/eleven/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/eleven/Solution.class b/LeetCode/out/production/LeetCode/eleven/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..70549f7da1221958e5152242ac5bb7f998acdba9
GIT binary patch
literal 1671
zcmah~-%}e^6#i~@H@gW7C4o>wMcYy}A=qG1sDP-gR-%E{2B9tf;6m20G;HW*Q_D;r
z`zQFqt9_^seQ6(Hu#V%KGmd{z$7%iUCMi%lBZ0f;p8MT%zVDo~;qPa^{Q=;8ti;ia
z@i?M5-+>P?(Sb=!spTUR)5`s^T0SxHX&f<(TezTL7cG2d;`2DVFdoAtd|_cmZ3=OG
ziLXo)1)@`~=LXXPS|+<7pkJ(&9f4y-*K_6?8!L`KFITGcB#X6GSzVC6tM)CY9;~@_
zfke@%I=3A!U#e9bfm`z?1!6zd{PG3gkv9d-WQyzZw#-+hSIL(G-}Ne!O%Ku4e8~wW
zvo{2+vb!1-0%t>IJ92?kU9ariIVT_r0!Fx@&HTE$s7QyGUc?kI>qW<_1Z#v#-<Mkg
zktHVTJFI1Ev#n?FaD=I&ET$=~vlPhHo3nB=tb&P*iCGFRxfM?a4WGq2|G$D?8Cn%V
z-;l0HikYRO$-@Roze349uQ+A}>#YU|#7nh?zv^6aRr5OAjXA3-WFv(>8*{j9;);#0
zag_pWlrV4O8*m7^UoO6lMO?FS9VD38FY=76ud#WY9Vr=gNgeAnC42GGM40&2#&`Ih
zJy8Ju*mxZSCVsH73|=^p^YY5NqxzZL&%~+lWl-}u1l3kYIj<ap&V5YC#ByIC`!d-B
z?QBP2|I9U6pL6ag-kGrEUbyLP<HIp+l2C(OZ>-eAnN?jW6k0(K&N5j!w;Hm_zN8Lz
zz7<2|&}6xMNMvcN9!|PeYmi8)$<(doukh^%_>MSogUNeBd57H;u&F>*j)|VRkzK$k
zzS6z?ngBE~7W%jz=Pu8u;L{k|g?L0Gg4ei4LuVXm+IACwew^S=sGbnT%VLqiV)Wh3
z{RKmNnA<^QdO%<PU7yg?x~9)-V@AptxQ}bvSTq$)8NXm=cn_Mugqb$?pbKncL|KNw
zpNLLaIfdGRnYMOdZ6lG^Q_<0F#P~Gy`3KMcxfc}=p6}i>xc-{f2lVpjL*~~*&J&cV
z*y`vc|88_3fh0f2Dfc7=57C+-a+#`rq!yRH8qXRmj?#G*{OZFS{JcqP5JlcP#Yp{}
z+S9ZQrL<KAWepOiN_Q7$@D?l5fm?W+IE^{i@eVR%k_{QPQA0%K=wbZmGxP`(!{T39
z{OdCD?&woQp2FZS&Jq-1Z(<n1drYD_^)th1e2zRp?D{U^#ayyu4|W8LxnyV4c!DmT
z9GiWN?%`yD?MUvRM>SOo3)D|BAXSSr6C~JAil<32&(f#@oNUI&IgD~=@l**D#B}lB
U%Ly`S%W0ks@l4<YVj~#)50DCEaR2}S

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/nine/Solution.class b/LeetCode/out/production/LeetCode/nine/Solution.class
index 8fc25b12d4e08020bbdf641738e5dad212d9cb04..56cb064c0c88557ee796e7b3e0b6e1fd1ac8569b 100644
GIT binary patch
delta 174
zcmXAhyAA<S6h+s)*JFqXlQ5ng4KpMP@s2`5LqkI};%jK{KhRF$8z_8;+6M?Hk?fr8
zlfBn|I8P@$>7+7fBEZpFy(pH0JDwk0i29*_LoWk4tLyh=-+I2@&|*uQ106ELH2x%6
zT=`^!9C;K;X?fx_33e338H$p-II#~VPDxbHD3wmxv)NaB((6k)5Nb$;5jDm%nb2iw
HO=R{1zAPE}

delta 170
zcmXAhy$-=(7=@pHZL~VILY1(w&`)CVFBS<4gF%-@+>XWa-GjM<YhZ9IMyu4DNZy>B
zlk-03<vqRpqI?Pz4sbR`ZKGH}s3v#RPK)dleJkEcZa!*rNYP{rI58v;p!dfJsYsFm
zYD8H09I1;_lu3!j*)*gNaZ6upm!@1du&mfz?W{ePw~0(l1)9-fPKO13mW)^#*IEAn
D%s(14

diff --git a/LeetCode/out/production/LeetCode/ten/ListNode.class b/LeetCode/out/production/LeetCode/ten/ListNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..3337b50a8a061a91706d5f33f569fc528209b439
GIT binary patch
literal 353
zcmYjMyH3ME5S(?Km>B1QfdHbROj0Bb9f$@ADUy{GLFv!t1Q(gJ<k(Suiy}gz-~;$5
z#GIg@*ty-&%-rtR_s1uIYg~kA;<ybTCk{>n3<8`98e5eMWG3*f-c^EbQfWI)%%++b
zPx?mCx;55RcN7d~qZOZf@`7Gste)4esV*N?nv;o>B2)QFmB!6~q+h+54L{fk!evpH
znSL-%+*uZRU75m8)@rLFggB4TLJ;8qZ9(*Z2|?e9rn$1u(?z=08TV`qM=M<MlqT=<
zSTqyi{6t}eIOH3#TTtONz41F_e7T1=mOUD8q&#$pF@wO)N0;^<vCjeqzcw;1lmX-e
Lh6;{2d5C`itus2&

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/ten/Solution.class b/LeetCode/out/production/LeetCode/ten/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..c50b548280b4dea0340a399f526a6ae31a9acf20
GIT binary patch
literal 566
zcmYjN%TB^j6r4+e3WA6)@U4+3D%hB~!?-bV1-QVN=<ZUhRBLN!@$o~h*qE4@xNxb7
zU*V7Vm|MZv+{}5+nK|kE*YgX2EzBkn#Y6%*<aJEym=cI@+pZn#2x!ICLxJe7cVY=-
zs<vy@JC{wXeIT0-J0n%kl+K}S+p6w0qe08|1%|4D<r)po=>)dtRs;rG(%-!^)n2w3
z4y(2w)G1wAJ*G*^k|+JOzX|)N(hnGX$GZ_oHv(y1)Z|rYrej(l+3-4T)7rC@a=LH0
zaW1cA3Nge<N?`^Wfz<zt1cnvGaHM-?>^ILXlP)2nZ%$L!x(%=hjekge5eTJ7)L9vf
zf-$!C1o04#2Z(A6j3Ply{SuJGAS>!4O;pQWiYd{}^*6+{?)p)^R(eF_6^kl_S+1AW
z$}H=p^8NQmw5xTwq(K=ihZZ@?<Y_uhlUd>%mN1VZ7EtEp1_~i-?bob#2yHQh3{Od7
f1;flDWEGKRreTEIX=w3JXgWsu3M7uP8Nv7uWB+Fm

literal 0
HcmV?d00001

diff --git a/LeetCode/src/eleven/Solution.java b/LeetCode/src/eleven/Solution.java
new file mode 100644
index 0000000..9f91e28
--- /dev/null
+++ b/LeetCode/src/eleven/Solution.java
@@ -0,0 +1,43 @@
+package eleven;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+public class Solution {
+    public boolean wordBreak(String s, Set<String> dict) {
+        if (s == null) {
+            return false;
+        }
+
+        int sLength = s.length();
+        boolean[] array = new boolean[sLength + 1];
+        array[0] = true;
+
+
+        for (int index = 0; index <= sLength; index++) {
+            for (int index2 = 0; index2 < index; index2++) {
+                for (String dictItem : dict) {
+                    if (s.substring(index2, index).equals(dictItem) && array[index2]) {
+                        array[index] = true;
+                    }
+                }
+            }
+
+        }
+
+
+        return array[sLength];
+    }
+
+    public static void main(String[] args) {
+        Set<String> dict = new HashSet<>();
+        dict.add("aaa");
+        dict.add("aaaa");
+        Solution solution = new Solution();
+        System.out.println(solution.wordBreak("aaaaaaa", dict));
+    }
+}
diff --git a/README.md b/README.md
index c818074..b5fbef4 100644
--- a/README.md
+++ b/README.md
@@ -152,4 +152,5 @@
 - [reorder-list（链表重排序）](./LeetCode/Doc/链表重排序.md)
 - [linked-list-cycle-ii(找出链表中环的入口节点)](./LeetCode/Doc/找出链表中环的入口节点.md)
 - [linked-list-cycle(判断链表中是否存在环)](./LeetCode/Doc/判断链表中是否存在环.md)
+- [word-break（单词切分）](./LeetCode/Doc/单词切分.md)
 

From 65cc3e20504b5a2d1f289b643e07efdd2ac51286 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Fri, 19 Apr 2019 08:41:27 +0800
Subject: [PATCH 17/24] =?UTF-8?q?=E5=8D=95=E8=AF=8D=E5=88=87=E5=88=862?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...5\350\257\215\345\210\207\345\210\2062.md" |  64 +++++++++++++++
 .../production/LeetCode/eleven/Solution.class | Bin 1671 -> 1669 bytes
 .../production/LeetCode/twelve/Solution.class | Bin 0 -> 3306 bytes
 LeetCode/src/eleven/Solution.java             |   2 +
 LeetCode/src/twelve/Solution.java             |  74 ++++++++++++++++++
 README.md                                     |   1 +
 6 files changed, 141 insertions(+)
 create mode 100644 "LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\2062.md"
 create mode 100644 LeetCode/out/production/LeetCode/twelve/Solution.class
 create mode 100644 LeetCode/src/twelve/Solution.java

diff --git "a/LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\2062.md" "b/LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\2062.md"
new file mode 100644
index 0000000..c2e5e3d
--- /dev/null
+++ "b/LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\2062.md"
@@ -0,0 +1,64 @@
+# word-break-ii（单词切分2）
+
+<center>知识点：动态规划</center>
+
+
+## 题目描述
+Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word.
+
+Return all such possible sentences.
+
+For example, given
+s ="catsanddog",
+dict =["cat", "cats", "and", "sand", "dog"].
+
+A solution is["cats and dog", "cat sand dog"].
+
+-----
+
+给定字符串s和单词字典dict，在s中添加空格以构造一个句子，其中每个单词都是有效的字典单词。
+
+返回所有这些可能的句子。
+
+比如：
+s ="catsanddog",
+dict =["cat", "cats", "and", "sand", "dog"].
+
+应该返回["cats and dog", "cat sand dog"].
+
+## 解题思路
+
+我们从某一个位置index将s切分为前后两个部分，分别记为s1和s2，如果s1在dict中，我们去计算s2计算的结果，然后将s2切分的结果与s1合并即可，如果s2不能切割，我们就从index+1继续对s进行切割，实际是一种dfs的思想，核心思想如下：
+
+```java
+ArrayList<String> wordBreak(String s, Set<String> dict){
+	ArrayList<String> res;
+  for(int index=1;index<s.length;index++){
+    if(dict.contains(s[0:index])){
+      ArrayList<String> list=wordBreak(s[index:],dict);
+      if(list==null){
+        continue;
+      }else{
+        res+=merge(s[0:index],list);
+      }
+    }
+  }
+  return res;
+}
+```
+
+这样虽然可以解决问题，但是有点小瑕疵，考虑：s="abcdefg",dict={"bc","def","g"},那么：
+
+- index=1 s1=a s2=bcdefg ,切割bcdefg
+- Index=2 s1=ab s2=cdefg,切割cdefg
+- index=3 s1=abc s2=defg，切割defg
+- ...
+
+注意，第一步切割bcdefg的时候递归调用了wordBreak，在切割bcdefg的时候也会切割cdefg、defg、efg、fg、g，然后下面几步也是类似的操作，所以说下面几步实际上做了一部分重复的工作，为了避免这种重复的工作，我们可以使用Map，将s与其切分的结果存下来，这样下次再遇到s的时候直接从map中取之前分好的结果就行了，不用做重复操作。
+
+想上面那样的思路写出来的代码和牛客网评测系统给出的字符串的顺序不一样，观察了一下刚好和上面的顺序是反的，只要把从前到后遍历改成从后到前遍历即可。
+
+
+## 代码
+
+[这里](../src/twelve/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/eleven/Solution.class b/LeetCode/out/production/LeetCode/eleven/Solution.class
index 70549f7da1221958e5152242ac5bb7f998acdba9..df5b41d4bcfe933e95fbc251a5a7beeeb62ab918 100644
GIT binary patch
delta 89
zcmZqYZROoi&B7VVz|6qOz`#&7xrL=-@;{b*>na8*25F!OP>eyDL7ssT%u-=cWng09
hX2@qyV^9R@5n{+-P-oC!U}4Y%%JV=}O<uuz9{{)*4V?f0

delta 92
zcmZqWZRg!k&B7VZz|6qOz`#&5xrL>Ii6v$7AC`RU8U`r_X`mobm_eCAo`Dg}QejYK
kU}E5AC}dD$Py}idV#s1pXV73^VbBE1^FUNhUdDPK0Of%W6951J

diff --git a/LeetCode/out/production/LeetCode/twelve/Solution.class b/LeetCode/out/production/LeetCode/twelve/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..171652af540b58fe3102c3e235044f56acad7381
GIT binary patch
literal 3306
zcmbtXTXPgu5dLPfo0;8A0xTr3+>zTRn<ZWVF~I;qfk+5QFvwLV*&!L&>@K^rK=6hN
zDrgi`M8NwkDpZL+go-IGA1!_I!6&PD@K;zA8o!>sWI{qwlu6}GpL4pu?$clQnaQvJ
z{_qokrMMD66nj-X6@UkO16YiGDvSVp*sGx<fGOydNvsSe_RG*EYuz$fWjKI?BE?0e
zM}|Zhl1RyLNJUyjCV)zTt%R*1E6>9Mazw?^0A`4fUO|azIHuug4bNzJR>N}|p4V_(
z!wV{2l$faZk~~lNaS|^F@Csg4aY{kyN-JU6jS5P_)$IzrYm+fk!GsnoVYX&_I?VJo
zqa)6hU`w*oh_@SQOXm4Suib5B6ijNdkC^epW?fq{p0%xHqCtWGNHQI3N}I+(1uMcW
z2aLl;UED}?)wS7aE78@ETcLKmuFbR?s$KIn>9o<?Vr6W?D1;A=wPv6(tJ9W19poYo
z&k@^Cn@ZQZ8?S2gF?v&lqs(_1FrbxVeKs<jal^cguD{LdN*H!F&Ft;FV+O_rxf^%u
z@94sv^G!zTwmC1)I21Kyt$55#D+rCrMShD3DWNXOu+5$nIcMs(nwe~z#Q3a4%sfg0
zo2k@eaMw+hxTn5RU|K<oEC1XbCmk+@BBSG|H8u!Q<!!dnd5}O(rLrHLUOKJd${o`*
zE~d-*|Bmi%SoQW8Rzg8lc-I&b8k~ML(p@a~$>VG*&@%acBtvoblZti~ukk`q5NJzg
z)1BrzOM1J!(6>vZnRF~c9h-Wju{Ic)Zk}341Dfb-WTVJ~0_b=heLCJipNcnioRP^{
zyrtu9yrbhB-lc0D=VkdE-qUeGmM`LxiqksY#|Jt-#77DyI_R#OLc!Eqm-6MO<70fn
z3Y)9rQ+%f5b9^x-Y_>A%uhZb@<;YZ(7>O7s8Rt<FOLlQ$@JE4121WilSgp5QX-t{e
z(~2fKmSMSyFLm_eD-~bs_y(6p#lE@YfGPJ=a3opHwwX5UB-^EYWYLMQ)I5|m;&N-b
zi!%q&P`y)PjxlDJ8QD-!)|pJ$ERW1avzIzua@0lRA-GB>56XK#ZYH|yZrX*b*`oeT
zwj<Z}5=C>qL|rtnr?i4UsmJE=b-Wqt7%NJ%iifQVyX(D>1j4D^MyAy~D*S}yklutd
znNrYqoR7q7q*A6Z7j>U7|1udH?#K<L*~y%ig3-`<Te?qW8N{fURNn2_#JN2cV{_MR
zZ-#dvF_VIse+ya3x-ER^+4N`{Jv@4@g+?zkAt_Ocv)xD4LE((;n8){bl;0eH7m9Q#
z$9p-GCp!?nnrl$Lqu{}P97~<W0Pd%(=M?Y&KUhGS^-C==KFV(nFP{@@BDF*C?6`)K
zYw)&4uX3%#!IAG8L8#!bVAbUG^H{XRgIM9<PsBs0r*;MZ8nBY~4^zL&v6sEZ;@&Fm
zt>&HwYaHDsj*P}LmDpumzdi&XLn*EI2Gz&_v<s*RQ5=AOd&qk=8W}{u!z-jhq%seF
zhVLrXbZ>0AuhMr3=V~LBz5$dEqC(V;*F;KWKA|?sv(=Y|N(V6UB1-$QKc`o(%F?8I
zEu;-1sL*7SNRt&JPpS6@)sVjsM92xEAJs#sWQ0}qflxqprv|5Sklm>aF%%d;NTTf@
z{`Q1#xPLevjfA{|m|g-o08i+3a=Vk+0Vc!GZ@?hG?WS`+3)4t+h`FADRhWrZuI#~V
ze)P>jH;W*J`RKy}-lYq9@h!$>gz+P)@e6A48*P54<)36nxY~~Z_h(@(9--7nRvsl+
zeq!vxI!Y>$6If5KO3B=LY(O*Xf%z}8d%ei+^*p<>`xrKoK|lUL3vIm)&r%mTv{ghC
ztsLVy{Y^#vRn%+cegyuTn5AO#l$%hMn}|~U2Nf!|sCfJ)YAD>m!oT6U!H`zdz=N%H
z*@kT_HWrJrn~>t@>=0&<ikU5u;H*K+_F#J?IHw@YEeP`p!aW6HenD7J5Ed4MMLA&z
ziwPXwR2!^jdDXN=rAWL&q*El*Mamb6?|Vc-tg+hu;lHE@bNn{3JHR|^%*7;Tcsd!F
z&y3YFW6RhNjbwN|54VMVumepn$dpB{PLiiSGIWNF2#-sdf|Ep%P7{94;t90#so@ln
z>zNRPDcMdv5ADNva#Z)_v>K_E+mr4S24=uB%zrd|Dt4&YsbUuyVD5n%m`ml|RPkWX
Ee<7<QQUCw|

literal 0
HcmV?d00001

diff --git a/LeetCode/src/eleven/Solution.java b/LeetCode/src/eleven/Solution.java
index 9f91e28..51c1e13 100644
--- a/LeetCode/src/eleven/Solution.java
+++ b/LeetCode/src/eleven/Solution.java
@@ -41,3 +41,5 @@ public static void main(String[] args) {
         System.out.println(solution.wordBreak("aaaaaaa", dict));
     }
 }
+
+
diff --git a/LeetCode/src/twelve/Solution.java b/LeetCode/src/twelve/Solution.java
new file mode 100644
index 0000000..95732d2
--- /dev/null
+++ b/LeetCode/src/twelve/Solution.java
@@ -0,0 +1,74 @@
+package twelve;
+
+/**
+ * @author dmrfcoder
+ * @date 2019-04-18
+ */
+
+import java.util.*;
+
+public class Solution {
+    public ArrayList<String> wordBreak(String s, Set<String> dict) {
+        ArrayList<String> dfs = dfs(s, dict, new HashMap<>());
+
+        return dfs;
+    }
+
+    private ArrayList<String> dfs(String s, Set<String> dict, Map<String, ArrayList<String>> map) {
+
+        ArrayList<String> arrayList = new ArrayList<>();
+        if ("".equals(s)) {
+            arrayList.add("");
+            return arrayList;
+        }
+        if (map.containsKey(s)) {
+            return map.get(s);
+        } else {
+            for (int index = s.length()-1; index >= 0; index--) {
+                if (dict.contains(s.substring(index))) {
+                    ArrayList<String> dfsResult = dfs(s.substring(0,index), dict, map);
+                    if (dfsResult.size() == 0) {
+                        continue;
+                    } else {
+                        String temp = s.substring(index);
+
+                        for (String str : dfsResult) {
+                            if ("".equals(str)) {
+                                arrayList.add(temp);
+                            } else {
+                                StringBuilder stringBuilder = new StringBuilder();
+                                stringBuilder.append(str).append(" ").append(temp);
+                                arrayList.add(stringBuilder.toString());
+                            }
+
+                        }
+
+                    }
+                }
+            }
+        }
+        map.put(s, arrayList);
+        return arrayList;
+
+    }
+
+    public static void main(String[] args) {
+        Set<String> dict = new HashSet<>();
+        dict.add("cat");
+        dict.add("cats");
+        dict.add("and");
+        dict.add("sand");
+        dict.add("dog");
+        dict.add("aaaa");
+        dict.add("aa");
+        dict.add("a");
+        dict.add("b");
+        Solution solution = new Solution();
+        ArrayList<String> list = solution.wordBreak("catsanddog", dict);
+        for (String s : list) {
+            System.out.println(s);
+        }
+
+    }
+
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index b5fbef4..0152df5 100644
--- a/README.md
+++ b/README.md
@@ -153,4 +153,5 @@
 - [linked-list-cycle-ii(找出链表中环的入口节点)](./LeetCode/Doc/找出链表中环的入口节点.md)
 - [linked-list-cycle(判断链表中是否存在环)](./LeetCode/Doc/判断链表中是否存在环.md)
 - [word-break（单词切分）](./LeetCode/Doc/单词切分.md)
+- [word-break-ii（单词切分2）](./LeetCode/Doc/单词切分2.md)
 

From f5a3eed5b214ba68e471453e0c1c0e51815a9f92 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Fri, 19 Apr 2019 09:14:27 +0800
Subject: [PATCH 18/24] =?UTF-8?q?=E5=A4=8D=E6=9D=82=E9=93=BE=E8=A1=A8?=
 =?UTF-8?q?=E7=9A=84=E5=A4=8D=E5=88=B6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...5\350\257\215\345\210\207\345\210\2062.md" |   2 -
 ...10\347\232\204\351\223\276\350\241\250.md" |  60 ++++++++++++
 .../LeetCode/thirteen/RandomListNode.class    | Bin 0 -> 375 bytes
 .../LeetCode/thirteen/Solution.class          | Bin 0 -> 1377 bytes
 LeetCode/src/thirteen/Solution.java           |  91 ++++++++++++++++++
 README.md                                     |   1 +
 6 files changed, 152 insertions(+), 2 deletions(-)
 create mode 100644 "LeetCode/Doc/\346\213\267\350\264\235\345\205\267\346\234\211\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250.md"
 create mode 100644 LeetCode/out/production/LeetCode/thirteen/RandomListNode.class
 create mode 100644 LeetCode/out/production/LeetCode/thirteen/Solution.class
 create mode 100644 LeetCode/src/thirteen/Solution.java

diff --git "a/LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\2062.md" "b/LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\2062.md"
index c2e5e3d..8b0dc37 100644
--- "a/LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\2062.md"
+++ "b/LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\2062.md"
@@ -56,8 +56,6 @@ ArrayList<String> wordBreak(String s, Set<String> dict){
 
 注意，第一步切割bcdefg的时候递归调用了wordBreak，在切割bcdefg的时候也会切割cdefg、defg、efg、fg、g，然后下面几步也是类似的操作，所以说下面几步实际上做了一部分重复的工作，为了避免这种重复的工作，我们可以使用Map，将s与其切分的结果存下来，这样下次再遇到s的时候直接从map中取之前分好的结果就行了，不用做重复操作。
 
-想上面那样的思路写出来的代码和牛客网评测系统给出的字符串的顺序不一样，观察了一下刚好和上面的顺序是反的，只要把从前到后遍历改成从后到前遍历即可。
-
 
 ## 代码
 
diff --git "a/LeetCode/Doc/\346\213\267\350\264\235\345\205\267\346\234\211\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250.md" "b/LeetCode/Doc/\346\213\267\350\264\235\345\205\267\346\234\211\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250.md"
new file mode 100644
index 0000000..ca23577
--- /dev/null
+++ "b/LeetCode/Doc/\346\213\267\350\264\235\345\205\267\346\234\211\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250.md"
@@ -0,0 +1,60 @@
+# copy-list-with-random-pointer(拷贝具有随机指针的链表)
+
+<center>知识点：链表</center>
+
+
+## 题目描述
+
+A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.
+
+Return a deep copy of the list.
+
+
+给出链表，每个节点包含一个额外的随机指针，该指针可以指向列表中的任何节点或为空。
+
+返回列表的深拷贝。
+
+
+## 解题思路
+
+![image-20190226161741675](https://ws4.sinaimg.cn/large/006tKfTcgy1g0jwcpj055j31ho0ea0ux.jpg)
+
+上图为原始链表，黑色箭头代表next指针，绿色箭头代表random指针。
+
+
+
+第一步，复制每一个节点并将其插入到原来的链表中：
+
+![image-20190226161821940](https://ws4.sinaimg.cn/large/006tKfTcgy1g0jwde8vhqj31ho0latbo.jpg)
+
+红色的节点即为复制的节点
+
+第二步，根据原来节点的random指针更新复制的节点的random：
+
+```python
+currentNode = pHead
+        while currentNode is not None:
+            node = currentNode.next
+            if currentNode.random is not None:
+                node.random = currentNode.random.next
+            currentNode = node.next
+```
+
+第三步：分离出复制的节点们构成复制的链表：
+
+```python
+  cloneP = pHead.next
+
+        while currentNode.next is not None:
+            temp = currentNode.next
+            currentNode.next = temp.next
+            currentNode = temp
+```
+
+![image-20190226162013065](https://ws2.sinaimg.cn/large/006tKfTcgy1g0jwfboa5zj31ho0emq55.jpg)
+
+
+
+## 代码
+
+[这里](../src/thirteen/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/thirteen/RandomListNode.class b/LeetCode/out/production/LeetCode/thirteen/RandomListNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..b555ee92ac591754825e5b4878f1da4fea002726
GIT binary patch
literal 375
zcmZ`!O-sW-5Pg%RiHWJHRa?c2$F>J^@uqkY3WZR?O75F<(Jko)(oN~#@*si-e}F$q
zoWx#bnXfl*-t2t;e0~AA!Fd1&Cq8VPdN}hiAan|m$$~&Lf}`cm5H1q)swyL;j-P~H
zmg_`q%)DI6TY_7)2q$++D|637quDs+@W2E@lqfCd^*WQ)v&afY`bn9KA{CWt>OJW2
zh7B*>5rRcoSGk<3hTL70MQv26uUBF#LIfCw=)ffm|M?T4*HGg^=$H60TgjX+ut(z*
zSA3?!XWMKn!5;8%&_=(F#Cd>25JJwTu=p`D`2bBW-(kIRWueRds8xwruLmE;TmyqY
RHln>|z&)3>i2Kc4{}(rwMbiKP

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/thirteen/Solution.class b/LeetCode/out/production/LeetCode/thirteen/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..f36864fc1fcd71ffad3c97df42950aa2464a1b77
GIT binary patch
literal 1377
zcmaJ=OHUI~6#g!qM_bF=DkG?ffQ61!9x4_wCitLQN)#g^8Z(p;2g{Vy*2mVBi3=BQ
zH2wg#n5ZO@xYWe0iGRWP7YqTvds}Es)J%KsH|KTF`OcZIn;$;`7{aMA!mv#o4WR~o
zVTy!A$E4^tF%X6cTZ%ywLjuNW&-aRF1Ol<1>jK(Xe%=+RPkX+bDJ{*pg=@}Sj+&-)
zKI`PJI|Wa^SCm@up7%hYInA?BbX`9&mCu!mUfv%OsLSS;pImkP`TSDadr%Y@idFrp
z`V21|>G`KcpjPIYygODZNLK;tKfb%NWv`6;m=^|%?$UBONW14c^8#kYE)bDfWnJUS
z5S9k_QQ5h6s_10zPdLk}O;Sl-mK@I)*b|#gFFFsMM9%RS5>v&3=P!&X-kidMWa2Mo
z0o`Ze1C?{Ia*}(cKQ15`Sy$L$s$7I{Xh;c!r}Cvj*1h1#Db#NB+b64tU>70+dw1CX
zlhp{0qeuFjh~Olm5ey?L(75BhohyPSGz&CT8=IV4bh9K-&pC5$j@`#ns!3nbYLrXG
zAudsvI|l?HWGR%jd`s{YJoVl+h_?hasG~HLayROUr7IoKfJUC&E;LgzSiEL3le#zY
zFVMwme8T<=dmS}1_B#aDpd~c|J!4zid+3&Slu|1An^@WUuG}rD;NN%;qiXvZr#7i6
zsVl!>ONJ#4+oGp#8K2Q$@t}^cD+pP-P<ocI^-U&9>ML7cEp3(M1yoBuT8Z~ULkrv6
zhalS6+J0C#z~>-3(T-m7G=L7yqLWkT#t4q!0%Ev=IHqCaHu<`Peq`yjh(Rp#8!plN
zDZQT|iRX-Xfzx<}F-6@~-eU3DjVSLuz}xo_1sK~$9AzCOuR^RuE!6Q-z)QwNIf`kV
zW2G|oHqNmAD96yon0ADW4G0taZDDP47DW7Qpo3EX#k)hQr}B({@Wv3MQgSpkoJ(2)
zjbK6ogCHY;Ns!be3QDBMZBn`pb7l>}q+uEH4+tgAz=>dWPkPl-U1a)k?nR0vUP2cx
zlcqGOnZ_t?;5=^9I;#k|RW5`L9AZHsoUOFnL;^ch%dMp5Fj0VcI{C=v6C|NaH9yLc
bb#o65X4N>HC_5h~Wij-SHo*bP4UYc?6%GtL

literal 0
HcmV?d00001

diff --git a/LeetCode/src/thirteen/Solution.java b/LeetCode/src/thirteen/Solution.java
new file mode 100644
index 0000000..0a7d6d0
--- /dev/null
+++ b/LeetCode/src/thirteen/Solution.java
@@ -0,0 +1,91 @@
+package thirteen;
+
+/**
+ * @author dmrfcoder
+ * @date 2019-04-19
+ */
+
+/**
+ * Definition for singly-linked list with a random pointer.
+ */
+class RandomListNode {
+    int label;
+    RandomListNode next, random;
+
+    RandomListNode(int x) {
+        this.label = x;
+    }
+};
+
+public class Solution {
+    public RandomListNode copyRandomList(RandomListNode head) {
+
+        if (head == null) {
+            return null;
+        }
+        RandomListNode curNode = head;
+        RandomListNode curNodeNext;
+        while (curNode != null) {
+            RandomListNode copyOfCurNode = new RandomListNode(curNode.label);
+            curNodeNext = curNode.next;
+            curNode.next = copyOfCurNode;
+            copyOfCurNode.next = curNodeNext;
+            curNode = curNode.next.next;
+        }
+
+        curNode = head;
+
+        while (curNode != null) {
+            curNode.next.random = curNode.random;
+            curNode = curNode.next.next;
+        }
+
+        RandomListNode copyListHead = head.next;
+        RandomListNode curNewNode = head.next;
+        RandomListNode tempNode;
+
+        curNode = head;
+
+        while (curNode != null) {
+            tempNode = curNewNode.next;
+            curNode.next = tempNode;
+            if (tempNode != null) {
+                curNewNode.next = tempNode.next;
+            } else {
+                curNewNode.next = null;
+            }
+
+            curNode = tempNode;
+            if (curNode!=null){
+                curNewNode = curNode.next;
+            }
+
+
+        }
+
+        return copyListHead;
+    }
+
+    public static void main(String[] args) {
+        RandomListNode head = new RandomListNode(-1);
+        RandomListNode node2 = new RandomListNode(1);
+        RandomListNode node3 = new RandomListNode(3);
+        RandomListNode node4 = new RandomListNode(4);
+        RandomListNode node5 = new RandomListNode(5);
+        head.next = node2;
+        //node2.next = node3;
+//        node3.next = node4;
+//        node4.next = node5;
+//
+//        head.random = node5;
+//        node2.random = head;
+//        node3.random = null;
+//        node4.random = node3;
+//        node5.random = node2;
+
+        Solution s = new Solution();
+        RandomListNode randomListNode = s.copyRandomList(head);
+
+        int a = 0;
+    }
+}
diff --git a/README.md b/README.md
index 0152df5..ed1a0f1 100644
--- a/README.md
+++ b/README.md
@@ -154,4 +154,5 @@
 - [linked-list-cycle(判断链表中是否存在环)](./LeetCode/Doc/判断链表中是否存在环.md)
 - [word-break（单词切分）](./LeetCode/Doc/单词切分.md)
 - [word-break-ii（单词切分2）](./LeetCode/Doc/单词切分2.md)
+- [copy-list-with-random-pointer(拷贝具有随机指针的链表)](./LeetCode/Doc/拷贝具有随机指针的链表.md)
 

From d653195a44741a2b6019560b63fbb44be71bb706 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Fri, 19 Apr 2019 09:27:38 +0800
Subject: [PATCH 19/24] =?UTF-8?q?=E5=8F=AA=E5=87=BA=E7=8E=B0=E4=B8=80?=
 =?UTF-8?q?=E6=AC=A1=E7=9A=84=E6=95=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...00\346\254\241\347\232\204\346\225\260.md" |  24 ++++++++++++++++++
 .../LeetCode/fourteen/Solution.class          | Bin 0 -> 810 bytes
 .../LeetCode/thirteen/Solution.class          | Bin 1377 -> 1377 bytes
 LeetCode/src/fourteen/Solution.java           |  23 +++++++++++++++++
 4 files changed, 47 insertions(+)
 create mode 100644 "LeetCode/Doc/\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260.md"
 create mode 100644 LeetCode/out/production/LeetCode/fourteen/Solution.class
 create mode 100644 LeetCode/src/fourteen/Solution.java

diff --git "a/LeetCode/Doc/\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260.md" "b/LeetCode/Doc/\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260.md"
new file mode 100644
index 0000000..55c92bd
--- /dev/null
+++ "b/LeetCode/Doc/\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260.md"
@@ -0,0 +1,24 @@
+# single-number(出现一次的数)
+
+<center>知识点：复杂度</center>
+
+
+## 题目描述
+Given an array of integers, every element appears twice except for one. Find that single one.
+
+Note: 
+Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
+
+给定一个数组，除了某一个元素之外的其他元素都出现了两次，找出那个只出现了一次的数。
+
+注意：你的算法应该在线性事件复杂度内完成，不应该使用额外空间。
+
+
+## 解题思路
+
+使用异或操作，由于异或操作有"相同得0，不同得1"的特性，所以讲所有元素顺序异或完之后结果即为那个只出现了一次的数。
+
+
+## 代码
+
+[这里](../src/fourteen/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/fourteen/Solution.class b/LeetCode/out/production/LeetCode/fourteen/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..be2bb26fbddeb95b858445bee3432b88bd3079da
GIT binary patch
literal 810
zcmZuuO>YuW6g_V~VLAu}i&bf*egZ>a<F2-eF)<;bVuB$dtOh#b)M2I>hDNuIzr>9j
zH@avOHT?np8@DEYoCh>bqnXUT_uY?k&VBFu?=NQn9-?l+#HNW`78GozQO1^xZd<s6
zyC&`l7?1qWPj&^=O0_4TJ&E=`fo$6ky=Sw@(2HNV!+@E5I~ut`&y9U~UM98Vl|L0I
zv|mQEIPtu&*^Po(;z!}OfIaoYaj--Y&?|#hwMFlT``#M?!B{*NPzDUt*dtD+o4BLb
zd+y;m{KWM`fnsIQK5&oRX5fb7W;cn6yFC}{#$!qUpRzz|x|AYdbt!M;J@w@xnRAH^
ziD@H+w7}{=3z)cX;{hr*vdEdJ+Ni-1$Xy8O3=h0faw*k)J59U^*NJ8<tSwagQS&(^
zClv0v6JAVVj&V6HU>?e*fct8dR<(yMzLUvE1XOSvq-ialn)HHRubo1CVxVA!)|e+v
z*o^H(12VY66JHZKS~+}7Fpd6(qc(Q5-3{mLJ+dWdqj9|RP8A>i{3v~7Rh=Uip)+1#
zzs)a$JncHMBtwl^gPB$Ss>EAz$*6#<WYbW@8mkID$gTW>A;eEkq;ZWn3q42dlk@e|
zH><B|oxY}b`nu8S8}z2uX@7;%KZUyY8Cu;rfqnwxV&^=kLB4e|mdWOjOR6g`Fmat~
UFt08&m07*XJ5k79VnxBmUwv$o{Qv*}

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/thirteen/Solution.class b/LeetCode/out/production/LeetCode/thirteen/Solution.class
index f36864fc1fcd71ffad3c97df42950aa2464a1b77..cc155547dbbaa3818bc442e3780bd6d1465b98c2 100644
GIT binary patch
delta 55
zcmaFJ^^j}BV`fID$xoQysJbz5GPpAcF?cXYGk7wnGI%lQGk7zYFoZGKGK4d@GDHGp
Kq9%W3$pHYA_YBSe

delta 55
zcmaFJ^^j}BV`fI@$xoQysJb(7GI%fuF?cdaGk7tmGI%rSGx#u=FoZMMGDI-AGDHDo
KqbGl5$pHYC3=G)-

diff --git a/LeetCode/src/fourteen/Solution.java b/LeetCode/src/fourteen/Solution.java
new file mode 100644
index 0000000..cb924e9
--- /dev/null
+++ b/LeetCode/src/fourteen/Solution.java
@@ -0,0 +1,23 @@
+package fourteen;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+public class Solution {
+    public int singleNumber(int[] A) {
+
+
+        int res = A[0];
+        for (int index = 1; index < A.length; index++) {
+            res = res ^ A[index];
+        }
+        return res;
+    }
+
+    public static void main(String[] args) {
+        int[] A = {1, 2, 3, 2, 1};
+        Solution solution = new Solution();
+        System.out.println(solution.singleNumber(A));
+    }
+}

From 1f256422a59627016f65153618c16f4ccd4a5ebf Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Sun, 21 Apr 2019 22:15:43 +0800
Subject: [PATCH 20/24] =?UTF-8?q?=E5=87=BA=E7=8E=B0=E4=B8=80=E6=AC=A1?=
 =?UTF-8?q?=E7=9A=84=E6=95=B01?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...0\346\254\241\347\232\204\346\225\2602.md" | 26 +++++++++++++++++++
 LeetCode/src/fifteen/Solution.java            | 24 +++++++++++++++++
 README.md                                     |  4 +++
 3 files changed, 54 insertions(+)
 create mode 100644 "LeetCode/Doc/\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\2602.md"
 create mode 100644 LeetCode/src/fifteen/Solution.java

diff --git "a/LeetCode/Doc/\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\2602.md" "b/LeetCode/Doc/\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\2602.md"
new file mode 100644
index 0000000..a62701f
--- /dev/null
+++ "b/LeetCode/Doc/\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\2602.md"
@@ -0,0 +1,26 @@
+# single-number-ii(出现一次的数2)
+
+<center>知识点：复杂度</center>
+
+
+## 题目描述
+Given an array of integers, every element appears three times except for one. Find that single one.
+Note: 
+Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
+
+给定一个数组，除了某一个元素之外的其他元素都出现了三次，找出那个只出现了一次的数。
+
+注意：你的算法应该在线性事件复杂度内完成，不应该使用额外空间。
+
+## 解题思路
+
+这道题是对single-number的升级，首先回想一下single-number是如何解的，它是用异或运算异或了所有数组中的值最后返回结果，其本质是使用异或计算出所有数中对应bit位只出现了一次的数，如果某一个位有两个数都出现过（两个数一样的情况下），那么那个位就位0，如果某一位只出现过一次，那么那一位就为1。按照这个思路，我们这里只要找出所有数中bit位只出现过1次的就可以，出现过三次的、两次的，都应该是0，那么我们使用三个变量：a ，b，c。
+
+a记录bit位出现过1次1的数值，b记录bit位出现过2次1的数值，c记录bit位出现过3次的位（c=b&a），然后将c中bit值为1的清空为0的就可以了。
+
+
+
+
+## 代码
+
+[这里](../src/fifteen/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/src/fifteen/Solution.java b/LeetCode/src/fifteen/Solution.java
new file mode 100644
index 0000000..cf11173
--- /dev/null
+++ b/LeetCode/src/fifteen/Solution.java
@@ -0,0 +1,24 @@
+package fifteen;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+public class Solution {
+    public int singleNumber(int[] A) {
+
+        int a = 0;//只出现过1次的位
+        int b = 0;//出现过2次的位
+        int c;//出现过三次的位
+        for (int index = 0; index < A.length; index++) {
+            b = b | (a & A[index]);//之前的b或上现在的出现了2次的位
+            a = a ^ A[index];//只出现过1次的位
+            c = a & b;
+            a = a & (~c);//抹去出现了3次的bits,~c将原来是1的都变为0，这样那些为与完之后结果一定是0，原来为0的变为1，这样与的结果由a决定
+            b = b & (~c);
+
+        }
+        return a;
+    }
+
+}
diff --git a/README.md b/README.md
index ed1a0f1..9ffb851 100644
--- a/README.md
+++ b/README.md
@@ -155,4 +155,8 @@
 - [word-break（单词切分）](./LeetCode/Doc/单词切分.md)
 - [word-break-ii（单词切分2）](./LeetCode/Doc/单词切分2.md)
 - [copy-list-with-random-pointer(拷贝具有随机指针的链表)](./LeetCode/Doc/拷贝具有随机指针的链表.md)
+- [single-number(出现一次的数)](./LeetCode/Doc/出现一次的数.md)
+- [**single-number-ii(出现一次的数2)**](./LeetCode/Doc/出现一次的数2.md)
+
+
 

From e7e5ab2b51656ec47140805ee81c644a69c6c778 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Mon, 22 Jul 2019 23:21:18 +0800
Subject: [PATCH 21/24] =?UTF-8?q?candy=EF=BC=88=E7=B3=96=E6=9E=9C=E9=97=AE?=
 =?UTF-8?q?=E9=A2=98=EF=BC=89?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...5\350\257\215\345\210\207\345\210\2062.md" |   6 +-
 ...26\346\236\234\351\227\256\351\242\230.md" |  68 ++++++++++++++++++
 .../LeetCode/fifteen/Solution.class           | Bin 0 -> 570 bytes
 .../LeetCode/sixteen/Solution.class           | Bin 0 -> 2361 bytes
 LeetCode/src/fifteen/Solution.java            |  18 +++--
 LeetCode/src/sixteen/Solution.java            |  48 +++++++++++++
 README.md                                     |   1 +
 ...60\347\232\204\346\254\241\346\225\260.md" |   2 +-
 8 files changed, 133 insertions(+), 10 deletions(-)
 create mode 100644 "LeetCode/Doc/\347\263\226\346\236\234\351\227\256\351\242\230.md"
 create mode 100644 LeetCode/out/production/LeetCode/fifteen/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/sixteen/Solution.class
 create mode 100644 LeetCode/src/sixteen/Solution.java

diff --git "a/LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\2062.md" "b/LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\2062.md"
index 8b0dc37..a92178a 100644
--- "a/LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\2062.md"
+++ "b/LeetCode/Doc/\345\215\225\350\257\215\345\210\207\345\210\2062.md"
@@ -28,7 +28,7 @@ dict =["cat", "cats", "and", "sand", "dog"].
 
 ## 解题思路
 
-我们从某一个位置index将s切分为前后两个部分，分别记为s1和s2，如果s1在dict中，我们去计算s2计算的结果，然后将s2切分的结果与s1合并即可，如果s2不能切割，我们就从index+1继续对s进行切割，实际是一种dfs的思想，核心思想如下：
+我们从某一个位置`index`将`s`切分为前后两个部分，分别记为`s1`和`s2`，如果`s1`在`dict`中，我们去计算`s2`计算的结果，然后将`s2`切分的结果与`s1`合并即可，如果`s2`不能切割，我们就从`index+1`继续对`s`进行切割，实际是一种`dfs`的思想，核心思想如下：
 
 ```java
 ArrayList<String> wordBreak(String s, Set<String> dict){
@@ -47,14 +47,14 @@ ArrayList<String> wordBreak(String s, Set<String> dict){
 }
 ```
 
-这样虽然可以解决问题，但是有点小瑕疵，考虑：s="abcdefg",dict={"bc","def","g"},那么：
+这样虽然可以解决问题，但是有点小瑕疵，考虑：`s="abcdefg"`,`dict={"bc","def","g"}`,那么：
 
 - index=1 s1=a s2=bcdefg ,切割bcdefg
 - Index=2 s1=ab s2=cdefg,切割cdefg
 - index=3 s1=abc s2=defg，切割defg
 - ...
 
-注意，第一步切割bcdefg的时候递归调用了wordBreak，在切割bcdefg的时候也会切割cdefg、defg、efg、fg、g，然后下面几步也是类似的操作，所以说下面几步实际上做了一部分重复的工作，为了避免这种重复的工作，我们可以使用Map，将s与其切分的结果存下来，这样下次再遇到s的时候直接从map中取之前分好的结果就行了，不用做重复操作。
+注意，第一步切割`bcdefg`的时候递归调用了`wordBreak`，在切割`bcdefg`的时候也会切割`cdefg`、`defg`、`efg`、`fg`、`g`，然后下面几步也是类似的操作，所以说下面几步实际上做了一部分重复的工作，为了避免这种重复的工作，我们可以使用`Map`，将`s`与其切分的结果存下来，这样下次再遇到`s`的时候直接从`map`中取之前分好的结果就行了，不用做重复操作。
 
 
 ## 代码
diff --git "a/LeetCode/Doc/\347\263\226\346\236\234\351\227\256\351\242\230.md" "b/LeetCode/Doc/\347\263\226\346\236\234\351\227\256\351\242\230.md"
new file mode 100644
index 0000000..1fbc76f
--- /dev/null
+++ "b/LeetCode/Doc/\347\263\226\346\236\234\351\227\256\351\242\230.md"
@@ -0,0 +1,68 @@
+# candy(糖果问题)
+
+<center>知识点：动态规划</center>
+
+
+## 题目描述
+There are N children standing in a line. Each child is assigned a rating value.
+
+You are giving candies to these children subjected to the following requirements:
+
+Each child must have at least one candy.
+Children with a higher rating get more candies than their neighbors.
+What is the minimum candies you must give?
+
+有n个小孩站成了一行，每一个孩子都有一个等级值，你现在要给这些孩子按照以下原则分糖果：
+
+每一个小孩必须最少分到一个糖果；
+拥有更高等级值的孩子必须比他相邻的孩子分的糖果多。
+
+请问你最少需要多少糖果？
+
+
+## 解题思路
+rating={1,2,5,3,9,2}
+candyArray={1,1,1,1,1,1}
+采用只加不减的策略，扫描2遍：
+第一遍从左向右扫描，保证右边孩子如果优先级比左边孩子大就让右边孩子的糖果数比左边孩子多1，这样可以保证从左到右孩子的糖果分布式符合要求的；
+第二标从右向左扫描，保证左边孩子如果优先级比右边孩子大就让左边孩子的糖果数比左边孩子多1，这样可以保证从右到左孩子的糖果分布式符合要求的；
+走完上面两步之后，可以保证不管是从左往右走还是从右往左走，孩子们的糖果分配都是符合要求的，最后将candyArray求和返回即可。
+
+
+## 代码
+
+核心代码：
+```java
+public int candy(int[] ratings) {
+
+
+        int n = ratings.length;
+        int[] candyArray = new int[n];
+        //第0个孩子初始分配1个糖果
+        candyArray[0] = 1;
+        for (int index = 1; index < ratings.length; index++) {
+
+            //如果右边孩子的优先级大于左边孩子的优先级
+            if (ratings[index] > ratings[index - 1]) {
+                //右边孩子分配的糖果数更新为左边孩子分配的糖果数加1
+                candyArray[index] = candyArray[index - 1] + 1;
+            } else {
+                //如果右边孩子的优先级不大于左边孩子的优先级，将右边孩子的糖果数分配为1
+                candyArray[index] = 1;
+            }
+        }
+
+        int sum = candyArray[ratings.length - 1];
+        for (int index = ratings.length - 2; index >= 0; index--) {
+            //如果左边孩子的优先级大于右边孩子的优先级且左边孩子分配的糖果小于等于右边孩子分配的糖果
+            if (ratings[index] > ratings[index + 1] && candyArray[index] <= candyArray[index + 1]) {
+                //左边孩子分配的糖果数更新为右边孩子的糖果数加1
+                candyArray[index] = candyArray[index + 1] + 1;
+            }
+            sum += candyArray[index];
+        }
+        return sum;
+    }
+
+```
+[这里](../src/sixteen/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/fifteen/Solution.class b/LeetCode/out/production/LeetCode/fifteen/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..c1ef9d70e296ee3a23235366bea398cef65112c6
GIT binary patch
literal 570
zcmZ8dPfrs;9DTptovxNvN^t>YYht)SAygB^80{v;#DoO(P{W1ObXjm<*(GI5JT->+
zNxXRR;>pAVAHb{e!*~(jjP>FqGw;ps{r<d}@4vrY0(gM94j;Ed+zzoUs691>sS<&|
zy0$9_o|pTXV0On8*{ku%FdMzm!<>=!PMPX_SC5RnPlG}A)|^@Gz#LRrR`dpCKCVnz
zJP|a`OmUb`n+VkE-uBwIKvHg^GR1!Oj{KRx+p~h^9txU+N~gy!^{JcTY|aVlgK|7d
zvlqsCY5p6td8E&E0|Atv^}h#(tlZ0WaoBr3Jj&7vcj58zc6s1qp?KDK>k);hx?dq*
zoE-A3xnPKE<c+@xxQ;q+f*BXF#Xs4|;$y$>C;pa-)cWN|Y;@xFNNrBuCk`+Aac8m>
z#8Kc~O!^%M$p<B$u71RyS?t3O?7HSNbk}6l7H*)8Mcl+4L|7r~VhQ&de}rXcD&gQ2
z>P=<_>~IgWWXhVE8nvv2IU4p@)u!q(^C9NRd{zPr@UB=|3lW7_5cd(k+>b0$^|15@
Df9qTC

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/sixteen/Solution.class b/LeetCode/out/production/LeetCode/sixteen/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..1c515a6b7c7a7c2b7653c50b785ef57c2342640d
GIT binary patch
literal 2361
zcmZuzTT@e46#jOyPfilTMdT<*Vk@OK=8(`@n<8kef|no~G-74w0|!Xq2qZKY)IQkG
zl<9Rk!%QFhqUa1SzSx<{OzZI4X<s|-f9P8uJCvG!`<xK$WsrT=-g~XJzxC~JFZ}7*
zcbfo?;bIUCI39!#{c0Fc!wEH<)R9tOXYW)1Z{c(hXE3N^NWgc(&fDdbfH!*Nx_}%k
z%;W@`N9=s=a%FKUSG;CTEpVlEq%dtQT(^q0n%5R(dCo4Wy^?*qoXh2VvxS99*)HS<
z1hi=@KXZrQ=tTNRnqNCVle;Y-XzN9*Z0Bbg>Y3nF<OPC``{`oQVvM&`Srll@maXae
zOV*NenvQm&oy#pO<%$g9ubi?<L>5q=L3J4G6!2fE*wgccV!3uSi_)%Sow-gZ>9i_S
zEc1|s!YwA5vuEeHK=;6?RV>>IJ`uXE1m|C}mkZ_j9AO3A)6Z4t;E$#!_@gTGFBNlx
zg-V_&<f3JBb6<2~<fgT3^)6WX+1_lq$YKW^daa_Wdhh>iGf%0;9^qJIBwMHyr*r3Q
zMStTCvk8?qgb*4-cnRGhyo|#knCJ;1fnI@@e_urid(o!jYzXIYUdM$H(io=SF22mv
z&D=D>Kev><Q!3|p1>Qo18-`nqUFaQUC1uu=vle;9dz~ErTqbo(%4vZ#$SBFiAxf`-
z3I+TS3OL6m&U*P3{A#fch{rTMXy)j17In1H4!I84gI3OXAlf)GSPVj=C-8~6c{2Po
zcscHs8JU!ZG&k1}GYy&GubfFdL~GoT{6||(X4c_Xc4kG2_3AHibCb(S#%ME1&CtF^
zpJ`}})Z`>1!*Ndd%gF;Y({OF3Q5m(wWKynZ)%EI+hI~XQUI%{485=kYL1(QEgln*v
zE*9|`3rKQ)0{bz9c4W{28wXH97<V~e!9l0&3yf^ybsE?QiDC3RmZr+BQK78;jNlD1
zs)K$W#(c<J?OYkcAUd7cFk{-GKSPty5fNQ-3))|36e70869muOA#^`81n7MuW^TYk
zR!wgrMMlkjtwY;P`n*Zq&<)=j`Z_d2PbB?@Kk^W5Br<Hs$&)Lds^L$qqm9e=(DdBe
zicYG32=6j<#;NfzFYpyAB1)c)kh2&qlQs8{r8rqi;5Zd>3a{cUSB7yEm+(49>35yG
zN*pN)Aj+Q?SgBtjuXA&w#*Lr;E;k{J;6?hWJ4#cLidV(WA;>C8^XuqR{0N67igFv>
zVhb&Q5Tr*vGgoz_Rn38hnCVs8*?@OfxIt&DA3+Q__|%=ywT`NxhRUO!Y%SqeOsMX)
zI~=(W`8Z~VBO4&=G?ZkSUujuRa@9G>)z|??`YA@9qIH@zonf7W1UlrLe9X;RKe?Ms
zE3NPx^5x>{ChIOA207i~!wcafY_^jcz&}ZpdS_#1m=7f!S;L4L_Lz}`A@3uw;^hPQ
zU2SS+n2Q-RVrUuHB}|tGbn#FC|8ZHbe*2sz`l&|XJaJzje`zu`j0kVM3zvyFLq%NS
zE4a!(UDv3GF<hhyM)5YX7_V!gi<(iDC_cyPwU5<nAFJ0sR;yiOj(ENH7WlTI3E8@h
zX3@IEmg8YY)umL!8DL&T#A>I!2TeYTcgh)=iE-?SZ$L}R9-4`sPR;E(oWzyw^qi}^
zd-u?yBAq>UqdwZI^N`B8YALG2%p}(6q>Oi*@ak_nJCljE>aXk7pV@xYVeCKu?L4!@
zImcdblf7r2x4uZV<@vvZCF<lovRNi)6|%OBcX10PypNCY0lsAK*m+Y~zB$!-G)CWc
zUX4_B*BM=P-jq_)s-tM7@>RyD&ZFMc9_acudPK)Iq|iFHD9-?&@X?y0?ov@I;bGs?
z;5fVXxb$YmH7zspJ$&OE&@c6vPvB2|gFxg7g1gVlz1WWl^HU!68C%!qEbR*icFfJl
g262p;TL|85j_tg<H=K(+$QF_0It7k5>El7)-$N^O?f?J)

literal 0
HcmV?d00001

diff --git a/LeetCode/src/fifteen/Solution.java b/LeetCode/src/fifteen/Solution.java
index cf11173..6f33128 100644
--- a/LeetCode/src/fifteen/Solution.java
+++ b/LeetCode/src/fifteen/Solution.java
@@ -7,14 +7,20 @@
 public class Solution {
     public int singleNumber(int[] A) {
 
-        int a = 0;//只出现过1次的位
-        int b = 0;//出现过2次的位
-        int c;//出现过三次的位
+        //只出现过1次的位
+        int a = 0;
+        //出现过2次的位
+        int b = 0;
+        //出现过三次的位
+        int c;
         for (int index = 0; index < A.length; index++) {
-            b = b | (a & A[index]);//之前的b或上现在的出现了2次的位
-            a = a ^ A[index];//只出现过1次的位
+            //之前的b或上现在的出现了2次的位
+            b = b | (a & A[index]);
+            //只出现过1次的位
+            a = a ^ A[index];
             c = a & b;
-            a = a & (~c);//抹去出现了3次的bits,~c将原来是1的都变为0，这样那些为与完之后结果一定是0，原来为0的变为1，这样与的结果由a决定
+            //抹去出现了3次的bits,~c将原来是1的都变为0，这样那些为与完之后结果一定是0，原来为0的变为1，这样与的结果由a决定
+            a = a & (~c);
             b = b & (~c);
 
         }
diff --git a/LeetCode/src/sixteen/Solution.java b/LeetCode/src/sixteen/Solution.java
new file mode 100644
index 0000000..40f6413
--- /dev/null
+++ b/LeetCode/src/sixteen/Solution.java
@@ -0,0 +1,48 @@
+package sixteen;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+public class Solution {
+    public int candy(int[] ratings) {
+
+
+        int n = ratings.length;
+        int[] candyArray = new int[n];
+        //第0个孩子初始分配1个糖果
+        candyArray[0] = 1;
+        for (int index = 1; index < ratings.length; index++) {
+
+            //如果右边孩子的优先级大于左边孩子的优先级
+            if (ratings[index] > ratings[index - 1]) {
+                //右边孩子分配的糖果数更新为左边孩子分配的糖果数加1
+                candyArray[index] = candyArray[index - 1] + 1;
+            } else {
+                //如果右边孩子的优先级不大于左边孩子的优先级，将右边孩子的糖果数分配为1
+                candyArray[index] = 1;
+            }
+        }
+
+        int sum = candyArray[ratings.length - 1];
+        for (int index = ratings.length - 2; index >= 0; index--) {
+            //如果左边孩子的优先级大于右边孩子的优先级且左边孩子分配的糖果小于等于右边孩子分配的糖果
+            if (ratings[index] > ratings[index + 1] && candyArray[index] <= candyArray[index + 1]) {
+                //左边孩子分配的糖果数更新为右边孩子的糖果数加1
+                candyArray[index] = candyArray[index + 1] + 1;
+            }
+            sum += candyArray[index];
+        }
+        return sum;
+    }
+
+
+    public static void main(String[] args) {
+
+        int[] ratings = {1, 0, 2};
+
+        Solution solution = new Solution();
+        int a = solution.candy(ratings);
+        System.out.println(a);
+    }
+}
diff --git a/README.md b/README.md
index 9ffb851..29278fd 100644
--- a/README.md
+++ b/README.md
@@ -157,6 +157,7 @@
 - [copy-list-with-random-pointer(拷贝具有随机指针的链表)](./LeetCode/Doc/拷贝具有随机指针的链表.md)
 - [single-number(出现一次的数)](./LeetCode/Doc/出现一次的数.md)
 - [**single-number-ii(出现一次的数2)**](./LeetCode/Doc/出现一次的数2.md)
+- [candy（糖果问题）](./LeetCode/Doc/糖果问题.md)
 
 
 
diff --git "a/SwordToOffer/Doc/\346\225\264\346\225\260\344\270\2551\345\207\272\347\216\260\347\232\204\346\254\241\346\225\260.md" "b/SwordToOffer/Doc/\346\225\264\346\225\260\344\270\2551\345\207\272\347\216\260\347\232\204\346\254\241\346\225\260.md"
index ca9c894..0854469 100644
--- "a/SwordToOffer/Doc/\346\225\264\346\225\260\344\270\2551\345\207\272\347\216\260\347\232\204\346\254\241\346\225\260.md"
+++ "b/SwordToOffer/Doc/\346\225\264\346\225\260\344\270\2551\345\207\272\347\216\260\347\232\204\346\254\241\346\225\260.md"
@@ -4,7 +4,7 @@
 
 
 ## 题目描述
-求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
+求出1 ~ 13的整数中1出现的次数,并算出100 ~ 1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
 ## 解题思路
 ### 思路一
 观察规律，以百位上出现1的次数为例说明，假设n大于等于100且百位上的数为k，则：

From 03eaac8bfd0126847c2edbbad5b2ec6cc56061c0 Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang@gmail.com>
Date: Wed, 24 Jul 2019 13:12:12 +0800
Subject: [PATCH 22/24] =?UTF-8?q?=E5=8A=A0=E6=B2=B9=E7=AB=99=E9=97=AE?=
 =?UTF-8?q?=E9=A2=98-gas-station?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...71\347\253\231\351\227\256\351\242\230.md" |  84 ++++++++++++++
 .../production/LeetCode/eight/ListNode.class  | Bin 0 -> 357 bytes
 .../production/LeetCode/eight/Solution.class  | Bin 0 -> 1246 bytes
 .../production/LeetCode/eleven/Solution.class | Bin 0 -> 1666 bytes
 .../LeetCode/fifteen/Solution.class           | Bin 0 -> 567 bytes
 .../production/LeetCode/five/ListNode.class   | Bin 0 -> 355 bytes
 .../production/LeetCode/five/Solution.class   | Bin 0 -> 1163 bytes
 .../production/LeetCode/four/ListNode.class   | Bin 0 -> 355 bytes
 .../production/LeetCode/four/Solution.class   | Bin 0 -> 1530 bytes
 .../LeetCode/fourteen/Solution.class          | Bin 0 -> 810 bytes
 .../production/LeetCode/nine/ListNode.class   | Bin 0 -> 355 bytes
 .../production/LeetCode/nine/Solution.class   | Bin 0 -> 1096 bytes
 .../production/LeetCode/one/Solution.class    | Bin 0 -> 1520 bytes
 .../production/LeetCode/one/TreeNode.class    | Bin 0 -> 350 bytes
 .../LeetCode/samplepackage/Solution.class     | Bin 0 -> 433 bytes
 .../production/LeetCode/seven/Solution.class  | Bin 0 -> 2068 bytes
 .../production/LeetCode/seven/TreeNode.class  | Bin 0 -> 354 bytes
 .../LeetCode/seventeen/Solution.class         | Bin 0 -> 2449 bytes
 .../production/LeetCode/six/Solution.class    | Bin 0 -> 2178 bytes
 .../production/LeetCode/six/TreeNode.class    | Bin 0 -> 350 bytes
 .../LeetCode/sixteen/Solution.class           | Bin 0 -> 1032 bytes
 .../production/LeetCode/ten/ListNode.class    | Bin 0 -> 353 bytes
 .../production/LeetCode/ten/Solution.class    | Bin 0 -> 563 bytes
 .../LeetCode/thirteen/RandomListNode.class    | Bin 0 -> 375 bytes
 .../LeetCode/thirteen/Solution.class          | Bin 0 -> 1374 bytes
 .../production/LeetCode/three/Point.class     | Bin 0 -> 444 bytes
 .../production/LeetCode/three/Solution.class  | Bin 0 -> 3162 bytes
 .../production/LeetCode/twelve/Solution.class | Bin 0 -> 3291 bytes
 .../production/LeetCode/two/Solution.class    | Bin 0 -> 1937 bytes
 LeetCode/src/samplepackage/Solution.java      |   5 +
 LeetCode/src/seventeen/Solution.java          | 103 ++++++++++++++++++
 README.md                                     |   1 +
 32 files changed, 193 insertions(+)
 create mode 100644 "LeetCode/Doc/\345\212\240\346\262\271\347\253\231\351\227\256\351\242\230.md"
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/eight/ListNode.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/eight/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/eleven/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/fifteen/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/five/ListNode.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/five/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/four/ListNode.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/four/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/fourteen/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/nine/ListNode.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/nine/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/one/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/one/TreeNode.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/samplepackage/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/seven/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/seven/TreeNode.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/seventeen/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/six/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/six/TreeNode.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/sixteen/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/ten/ListNode.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/ten/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/thirteen/RandomListNode.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/thirteen/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/three/Point.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/three/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/twelve/Solution.class
 create mode 100644 LeetCode/out/production/LeetCode/production/LeetCode/two/Solution.class
 create mode 100644 LeetCode/src/seventeen/Solution.java

diff --git "a/LeetCode/Doc/\345\212\240\346\262\271\347\253\231\351\227\256\351\242\230.md" "b/LeetCode/Doc/\345\212\240\346\262\271\347\253\231\351\227\256\351\242\230.md"
new file mode 100644
index 0000000..c9eadad
--- /dev/null
+++ "b/LeetCode/Doc/\345\212\240\346\262\271\347\253\231\351\227\256\351\242\230.md"
@@ -0,0 +1,84 @@
+# 加油站问题（gas-station）
+
+<center>知识点：贪心</center>
+
+## 题目描述
+
+There are N gas stations along a circular route, where the amount of gas at station i is gas[i].
+
+You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from station i to its next station (i+1). You begin the journey with an empty tank at one of the gas stations.
+
+Return the starting gas station's index if you can travel around the circuit once, otherwise return -1.
+
+Note: 
+The solution is guaranteed to be unique.
+
+在一条循环路线上有N个加油站，索引为i的加油站具有的油量为gas[i]。
+你有一辆具有不限容量油箱的小汽车，并且这辆车从第i个加油站到第i+1个加油站耗费的油量是cost[i]，初始的时候你的小汽车的油箱里面没有油，你需要寻找一个站点作为起点。
+如果从某个起点出发可以保证你开着你的车绕着赛道走一圈，则返回起点的加油站下标，否则返回-1
+返回起点加油站的下标。
+
+注意：给出的实例可以保证解决方案是唯一的。
+
+
+
+
+## 解题思路
+
+贪心的思路，计算从每一站出发，到达下一站后车里还能剩余的油，然后按照剩余油的多少进行排序，从剩余油最多的站出发，进行模拟。
+
+
+## 代码
+核心代码：
+```java
+public int canCompleteCircuit(int[] gas, int[] cost) {
+
+        //remaining为二维数组，remaing[index][0]代表车从第index出发到达index+1站后里面可以剩余的油，
+        // remaing[index][1]=index，因为后面要对remaing按照remaing[index][0]即剩余的油量排序，
+        // 所以要把原始的索引记录下来，排完序后直接从remaing[index][0]最大的值对应的remain[index][1]处开始开车即可
+        int[][] remaining = new int[gas.length][2];
+
+        //gas[i]---->gas[i+1]  cost[i]，计算remaining
+        for (int index = 0; index < gas.length; index++) {
+            remaining[index][0] = gas[index] - cost[index];
+            remaining[index][1] = index;
+        }
+
+        //按照remaining[index][0]对remaing进行排序
+        QuickSort(remaining, gas.length);
+
+        //由于上面排完序是降序，所以这里从后往前遍历
+        for (int index = gas.length - 1; index >= 0; index--) {
+            //如果剩余的油大于等于0，说明油足够到达下一站
+            if (remaining[index][0] >= 0) {
+                if (helper(gas, cost, remaining[index][1])) {
+                    return remaining[index][1];
+                }
+            } else {
+                return -1;
+            }
+        }
+
+
+        return -1;
+    }
+
+    //模拟从第startIndex站出发，看能不能走完全程
+    boolean helper(int[] gas, int[] cost, int startIndex) {
+        int count = 0;
+        int curGas = 0;
+        for (int index = startIndex; count <= gas.length; count++, index = (index + 1) % gas.length) {
+            curGas += gas[index];
+            if (curGas >= cost[index]) {
+                curGas -= cost[index];
+            } else {
+                return false;
+            }
+        }
+
+        return true;
+    }
+    
+```
+
+[完整代码](../src/seventeen/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/eight/ListNode.class b/LeetCode/out/production/LeetCode/production/LeetCode/eight/ListNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..6d2a93e28de1e4fe0c4b4538af8d74a68e7496ef
GIT binary patch
literal 357
zcmY*UO;5r=6r61fm0C)ziW)B-fdf5y(0DO1A!*=%>3v%_u%xz0X$gPJ12OU75Aa7B
zXQLMnZ{F^_nfLMa{qYIl7FQlRIPJl~nSpZ`Ll+kU_D&W8VkY2}YTpQiiPEce6DNAx
z%&Ql5C(ymurEVT58O_Ei(<6C-L841FZ(lQ2Kg+Bj6D3tHi&WOy{QpR&S?euF>;=4K
z)z-Os(nj20Rz=(Bs+?}*PWte0>7xtR#}Rr0!T&Y5n32VWELZU&+o+to+M{ub8=lkQ
zjTVD;B1{LOV0buY_W4>+VKjruJH+Jr0Ba%+u-`~o=o2G0Vwo7yeu98ZKxX)BW5qNz
NijZS?5jDme{Q!`gJahm6

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/eight/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/eight/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..a71209810f2741a8ec1ad9a147f18bb67d51f9db
GIT binary patch
literal 1246
zcmZuvT~8BH5Iwiu?Y5<SR=^4<h(KXm%9j|yh=L+$TVjeN1dUnB0*j?3%T|5h$>@VI
zCPw@ZJe#N_lK9AjKfoVgV&b1bJa^lI4<?&CXXehGIdf*e|M~h2z!eMx;YUvZUPLwY
z25I{==s~FHkw;8JT)=nD%3IEL0dKT-K|q-*te66|Nh@!ri<`@)J#Q@M7->irvPN#f
zur2AAgNn0mZ41;TO>1r4Nn{GSqGJ{E;{sK-S+G}3J85k@0^w*mL%L~p7?-{Lj=8xd
zz0(RO_X2^+?chInhzwT^SyI`~6`l!bTeev$5inLA(=K6U-85DNsxyv}eUdV^Ds(pu
zD=*L#T}o~kPmM&*$gd?bj&0@FTtbRruW_94f35}8Jejh;Ylq8rq--y9n(gxR0>Mn7
zXlKo7OA1$AQKet@3?YDE2>l2P)Ra`K%q*`GC(+8Q5b97*fldj}EpM1vsX*R*E=_c{
zcL5z-sGnO0w@ked<XJ^8K`Ut0zI}*~1RjKV`rKe6s)<9T1k|9G9$TTFCm)MlX3L@<
z^h3PYKf!Z|H~L~a6?0*mG%gC4Q7TS1y?6Xm+A$?AKEo4HBvvDe>!^olji@r>i!dhd
z)iEXF8&mg=e?^o-=xo&^TQR|Xsp+LOCdq6~W+(TKf5=(9?kvkVOWaJx5l+y8cC;dj
zHVjadQC!40Ix&e$m_avE=)pX1m(YvH=tCAdR=JG=g(~vJ4hHc8LwJp0yu}FKvBEAZ
zNSz*1)_HblK$!X!+3Adnc4!-kG~T^L6Oo5nz9OSA8IIx+`Guj7!+kOgb5T^ZthPkw
z7!#}p@>GvdtHH~!{Rqt^)OL&*JQ`HGObT$kw$g&|n-Pt%g#&mOm3=5l2~>iV1U`ba
z1RBAZB9UJrRgY22Se!?^qOMBk0P5mCe3ag&e}Q)Ty9~KPPq6n5j(?M6C((r|igueK
zP2(!=V1fcqV-|C`iwC&pN;Xqshx54LGEbF<ZNM$ANeb0MaXW~-tT)JINud&4QYVqh
QS{fHu>;A4?tl&ZSUsE9B82|tP

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/eleven/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/eleven/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..5efaf9b96578c8cdf94d74772d72b96f03a253ca
GIT binary patch
literal 1666
zcmah}-%}e^6#i~@H@gWN3V~3AqHU=f2yL(^)PSh1R-%E{hSC=N!G)~Jwqb*tO)Y)y
zpWq9x_MtxXrG0?GI*xD7IQ~T)r}ev=@T+vjB-}ms+;h+QzVn^s@8`e$0bl|$j$TZ}
z5yklqe29Dp&R|k4QzkxA?rF7rY~qtRVwkY-sS3Mb;i8Gp;^@Rg44>nYg)h`*CXNEW
zH1U-{bjtPIU|K-S3@r%g7wct5;8@Z1oVn)OisR4Al^Q+CVtrNC7Nqa0ecP!ARktC~
zU36;B9mmU+>a}Lz*1buA*iUu8e8G3*ZGqF7;w^bc=4#Tb<Vu0>dX>qRhtaiM$q6Qh
z76q)byBZV%XH8W*a)D4?uk74CCm;#}M!2EP`ntNPK!=z1atfG@qT^M9D#NAk%MF3Z
z5)1Vm=CZNA%V+R#hN+_{rb#VP3gqhTS-Bo|!9>PHk%UWb#gjqPXS2@#FX30FR!z{?
zr0Wr4X6b10P$217NV(?~$LwIEEr3A0RB!sL&Lvlgm)I5Ntm=@B6#8t;V$Q^68&~kP
zjjJfxn8!7Nu9rJ+V*%G~+`vsLz2D&(*{D)E4vv&exu}kHnvz1iG!7<~Y<z=nDToT-
z$Hp5NF!7y@@3DNS=H-=JjuJDuUx_2(%b@Oa0%~nJIjo$4#C}YO#B%o{`!YiZwA{@=
z@yx1h%sF=z?o8NkFWmI*#)mW70->h3(OhYS1FIw{6xvA-4l+?WKQ?8JqNEPW-p-+F
zXtG>BM6$He2*+HjHwh%wLh9CYSNLiKd_f$!#^OC8y~A!2SXV(c&WN5_99qChzR$h<
z9|34!F7$Cd&RvdA!KX324e^*p1g~+8hR!(BwCz>^`tdq<LTSP%UKZDwEJokG>|Zdn
zN7*ezrU&%p-}Stn)-`=z8#hwMzysXS#-pid%J>B{BRkLp@@CrHfiAF#QDqqde<GT<
zvMOo|X4=|<wTbSuo{ElbBF3ko&p&+e&;6))_+tCM!S&a)J}~x()%6f@o&*(E9SNfE
zLI=8$<o7tqo*>;}S~HAXCZ`|B#HFv!vnE@kSYCz2^Edf@i`F2DymgY9`muylv<$_w
z-2-I}GEOz_9!}$J_M?N@-eH`^npM1u43P|lh<2lf8I`4n`J>O#BTS5le_`>j)5Mvv
zXNWw5!5_{tC_-go7{z-mqICM1=`=n^pCWd18}VW`*|7sVg6r92qGdcqCr^&eK0((=
zvYTQgx6q>`)xrk#lMD#eBFt_A>?g!igqUM%R0B@5^5Y!FxU+bwhzZ7Y;(azOvPY+N
NHq0}D4;UN4_<yWjV`KmT

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/fifteen/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/fifteen/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..68b6e53a33c1fa869d49f49eef21eb7e97d25f65
GIT binary patch
literal 567
zcmZ8ePfrs;9DTppovxNvN_7FXH8EVE7^(*_M!ShIF(E-c)NtW6T^1Z%cTL$EPYoe_
z5-wi6crx+82k>hAFkZwrW4*Y^%=^uIzdvtgzyJPr0pKBS*AZYj!p#V`1hpr&uvH=m
zR@Zg~;j?l-6U^_}B6~S`H_FDZ%_t|+-YHX)@0zi7=NTDRZ|t$t4(vgdWkr8j=99{n
z#bZI^*cONRtcgIc?rpDa3nb+tYFq4Q9~nOts68hbu92WQtW5g$g?aC1L|72ihvj6P
zX3woN()>4L<H&q44TR8w*8c`bIk}&k;;{c}bd;qP?n3eA?o;4Rp}E(1>Jx>idtV`6
zyc}__c{0Kk#*M!TxQaSYf;rE);-75f@KG=bl3+{6di~-Y_qv_+SZ_>E5|5{YPItN$
zcH&T-P6u5N$(fc<mp?k6SscI(?D^(%bk}6l7OtU<CEUOr#8_d}!!jO_=P&f85)NLW
z-ehLT4)-z7NINq#qb_P;frb^U+Ef)YH*uX&z)D~d>XN0k2r5D>{vm$(7g?mLu=EGO
Cqg%HC

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/five/ListNode.class b/LeetCode/out/production/LeetCode/production/LeetCode/five/ListNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..23a6999cd765ebd1a94e213a16cb3c49c245527f
GIT binary patch
literal 355
zcmY*U!A^rf6r2TG1gX@jRpZ5D%b^@SXuO!1G$HMwhWmo6ZiA3eApI>5jfn?8z>hM{
zMlWXb=IxuEH*eq9_s1uIE1di2;mCu7V*@8H#x70;>`oQ}VlLp6YTF2e$&>C>oajxn
zs2<g|K>tRUy1AudGM}bQcjS#wmuk_zW~zRWSwUu$RJkltS!+}OkxuiXH=M8)@K;q^
z=jvV?@nBUIZKJDlww9d?;NvVnA8vp>czpi%3xT0g#f2=N<7Kv1Ie%(TrYSDDOphB{
z40aP?42Xi^W1l(TZApdEgwZ=hbg_dKi5=`WQWgfp5sg5p!^*<}Psjkqziq6HDGe~>
L7%qfERu)D-n;bis

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/five/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/five/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..828cd69a5c5aa3c97450476fb44c753d06f309c4
GIT binary patch
literal 1163
zcmZuwOHUJF6g?lEX*;F7N<~NH4N{nvBH{}aH28p|l$a6>xEjg;17%9eK){W0=SmYd
zt~DlXF+oWraS4fk!}uRusCd3<3yCplzI)Go-*czm{(Sig;0F3b(9o&DhpqrFhbX%x
zhy~CSf*+mo=?%aT@ZYu_+Z_?`#d>B0l(GDRB~X*H9V@-LHg6TC&G{THkyJiw=4Q--
zEpf@HxXbp2j9#?2tYjvi+jQ-`Gb~VNI~!I(f=s^PrtA$@pfy$ulPJwD!#)3Cf$D62
zeP?QM+FDy5x6Fmp%BLv;p<+nUt=Z0kwJnQr@?|e0=$<AAvYUmXuPWo3+0{vNy*&4t
zX*&W9v8SmObIVNTOlK*XaSOJyH0-fp7M8eI{eRp7s>6N*C3!_4xKY}h!)5ZDg{<|^
zmW)-E`RJ29!U&-<j5wn7cyyJQlAc5ueMpu)<-{=R5D}<7n{jG>#mbUP#j&=fh)u|G
zeOqQuKun;GXVv%tfVbu}sN@?aN>U0+wf6wxBb5qN@%4Mg2&$=vivg%XEfFt>2wx_P
z9Tp4F_SQH;$k<24F;rvk5WZR80hGzO@d*`1I&lOyLFbU7D@SP7m3^qh>N`ZFPP_D`
zcTc|S$}xg*g1z{VD&>%0_cPK<d5@^BN}DQebnTw}(CK22gja`(uIPS>-IG^d6^`cf
z)|o>C^(ePKM|^=uM<Xtw2`yx%4c%zRO>|%sop?l)LJW^#V47E%BmYa}$w5E1F@Wc|
zikBF~YyO$u;Fd?xIBA&1FzVSuWyUr3iIT)_tg=@WiX^E-pw!OO#*YjyI7^h2H{ls4
zigMbEjBJNiDSo3S03Uz9pz&?dej`{kH2q|(=FMNc;Roia%)2g`_mlaQR8)BasVG#^
zMx4CF6MPQgpFKc8Uc>l|;FGhXw<E|ZcUXIbCmv;oyJ*EdbYYAf+~-ygyln@I-8gkK
h<258o`$WiIi?>fBb6dTA`dG7#ACAI(+ZkPfj=$V!*-rof

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/four/ListNode.class b/LeetCode/out/production/LeetCode/production/LeetCode/four/ListNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..c73b577c1a9e93a4302023f41bb36a13c3387b2e
GIT binary patch
literal 355
zcmY*Uu};G<6g($sLqkeR3I)W%*k))(1`rDpQl+RJin2SwfUA&5X;SsK7%C(NK7fxx
zoPmYm-Lubk=l4Fp-ai0b;><$_!yX(Q88~(^a&aPHZ)71LW&%#Bwv9lLJXUQTCwkq?
zs|R%@(7o2BZf>X;&n79`EqNo<rJA=dnX2z)R*(skDwjnnYi;g-q|-d>HGkL&cuOYd
z>P{PRe_0i6qpNbdk{jv6!>NxhTpxSr@%i5r0t2Ip3t2wJi)^KGPHK-QDK5B7hZ|Zf
zx`{9WM8Wc~&+hZIpu%W^=nWz|-@%H+4)!Z43w>h9AYec|q&>s|hAd$8YeVo8$^dFy
Kh6?J8H~a>^#yiXa

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/four/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/four/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..8eb34b6b7bcb99c500fb91905e7778126f7193e0
GIT binary patch
literal 1530
zcmZuxU2hvz5Ixu4^?DtrNs~HsOGyhft>g6v%|{cQG(bNPrnU=p6^JMgYiHwZan_OT
z1bz=Mc`Xt&5|wx~QvX6<dE!5maOT=hq<|dXId|^dJ9EyA^ZK9P{{XOpVgd=|ZI~z|
z5XVQd+_tcgpl4CsOBR;JnYVC9A+{cbL2pALnx5ZOFz&aveT9i~5c<`Fy}I9d>eXBH
zOqJUWueIrQ0@)9pMsGLhO7u?qpi`)|TL-<M9j+<FyX{V|9CUjM*VBVj*;V=Y+Wfga
zlkWQ7_USXHfeLoF=XLZg1<Mb&<-UU137Wfn*=YGYG~>0N*Z860?GKBx_xw)NA0#iF
zPkt`<e``th{Js5A2?}bTdG@>@RG3MBSAOmtdWDu3HVd_0CkUHsS~IWHqzcpjbIf8x
z*1RyZi$l9Kw97-wKIpg=t=vFG=Jxn4DI{uCx8Z*tNFT;WD(9t^B*u_Tvg@fNrZAnv
zySU02-Hs6niCInJW4NP}(Gv=jXM`TtpZg6_HS~WHlP(Fj=%Lrb`<#{phYK*EBqP^x
z?h3Su*32A3{X!7I1+FpeoWTUKgfak=xJb(}!ZcU8{5PVE1fIBkB-~#S`4gu5!mS9b
zX8V}U^>HP~O&`-)nu=gKJ39F*BaWAd7LBa>4Uvp1*vvSlW4wg%g0Dt(C3zMLT;}R9
z=T%np9xmY;KE!pTNox^vxQm;(hg&EiqbuGRR5h%a_3=iEHBaC^W{4u(Z{QuGDDS5D
zdWy1?U^7RGOs_EG1sG%MEn*f-{>}0Z`!e9Is41g>`YV`Q(PPA_xuQW0*2#I5<SlZu
ze#T|Ta7oQE$du<?%SR_~93y+?)T$hv^m*AHMDqzE2@$c*blA|$@~pAIj@%}L1*#zI
zmypFWSN`9?Dn8?sl(3Epnbq(KzQL#X9uM^Gr9suFy3{pa>26(X5aH`v)K_##ViU7k
z7g1vZ=368OTHLy1+YG$M2Iw(RD-4&}`cdRCC`Va<Nl+0G6M+O+1VuwoT#zYfQcjC8
z4fVO@I+o~T<wOF}A?q08FdUQS72;dRu#0ggE)!FZ-m%Z7_8yr5U$D3mr}Rs9>=E@T
zQ?UxQsp28NqUURVo{(J)&+rrtq83%^;#(Y&y-fVhfDWhY1MX~u!}*zl&$&zKS$KvU
xTBkX_HK%ndF!N0!lezA48dIFYhwM_C$YPE$%<~r%XBNddb@{Gh=j0cc`xm6%5C{MO

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/fourteen/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/fourteen/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..eaef3a28487139048b643edebe1de284f5bb5abe
GIT binary patch
literal 810
zcmZuuO>YuW6g_V~VLAu}i&bf*egZ>a>7urYF)<;bVuB$dtOh#b)M2I>hDNuIzr>9j
zH@avOHT?np8@DEYoCh>bqnXUT_uY?k&VBFu?=NQn9-?l+#HNW`78GozQO1^xZd<s6
zyC&`l7?1qWPj&^=O0_4TJ&E=`fo$6ky=Sw@(2HNV!+@E5I~ut`&y9U~UM98Vl|L0I
zv|mQEIPtu&*^Po(;z!}OfIaoYaj--Y&?|#hwMFlT``#M?!B{*NPzDUt*dtD+o4BLb
zd+y;m{KWM`fnsIQK5&oRX5fb7W;cn6yFC}{#$!qUpRzz|x|AYdbt!M;J@w@xnRAH^
ziD@H+w7}{=3z)cX;{hr*vdEdJ+Ni-1$Xy8O3=h0faw*k)J59U^*NJ8<tSwagQS&(^
zClv0v6JAVVj&V6HU>?e*fct8dR<(yMzLUvE1XOSvq-ialn)HHRubo1CVxVA!)|e+v
z*o^H(12VY66JHZKS~+}7Fpd6(qc(Q5-3{mLJ+dWdqj9|RP8A>i{3v~7Rh=Uip)+1#
zzs)a$JncHMBtwl^gPB$Ss>EAz$*6#<WYbW@8mkID$gTW>A;eEkq;ZWn3q42dlk@e|
zH><B|oxY}b`nu8S8}z2uX@7;%KZUyY8Cu;rfqnwxV&^=kLB4e|mdWOjOR6g`Fmat~
UFt08&m07*XJ5k79VnxBmUxw9`00000

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/nine/ListNode.class b/LeetCode/out/production/LeetCode/production/LeetCode/nine/ListNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..c5340ad90701bc1fde9bc58c95f34a5d188564e2
GIT binary patch
literal 355
zcmY+9F;BxV5QU$Uw4os-C4~ZFVQf2)kpaYlgj6YNhobCGu)tMtq%^7ew-_oU27UlP
z3h@jq4EN4HfA@U%`Stz*;0k8}IvDog;mFFdkCBfP0e2%y0WlNsjM_E=QEIeNNvhY)
zyn0mE0^J*JbaP8$Jey=pcdT2G+`N6sRsA6Il9f2E3Rz~d*7p8a^qObA<_}weU|F?w
zq3*SX`^&0q8(o>pmE6b>0Zv17;fL5mkI(<65Exi0DW!Qz7WqmQoYWmpGF)((4mWfd
z?54sRPz58vK6A*^f`nzF=^MoKd<SPLc5q)=a?q#7Gy(?HL$=2_z>ooqe%lcJn9_iZ
KPg6n8_Qv0y3_GX*

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/nine/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/nine/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..3802afe43ed82ce9fcd8c9a8c362fb3c80e06b36
GIT binary patch
literal 1096
zcmZuxT~8BH5Iwis?Y3nLSfGH&_lKn)6cGU_5)F}rq^-shlIqh^R#<FzNxMb)LCPx{
zghUb_G4WUU=C4pZyW5HyljhFcnR92(nR~Zie}4K5U=d4Uv|&612@?t?!?aThZigXb
z+*#rwOe5i>lVPNgRxl$FSTRh)UKNny(^~@mHETx~=*StSUT9Re_1dPkU121ev&vd!
zORE{qz8Un}dq&+sn}lbIR;6JZmYEf3+tF>kY_A=aowFlx50EqJc7gS?)Bo(*cTd-L
zepmVpWa6b(w`uAX>$O0nXlvzHdF`M@psE?BKrH?ux33*)nTlraW{P&rFn6=A9IduX
zf?fYf3&<w9%n1bRP2wCvO(#5Dv>LUtzHT_=BQ04oP6rh#A}TV7G2^Okadk4Ytzhen
ziY|03xT9hYcU8>eo`MCHS4Cv!HRC7S`<xb4n)(~Z#5WxBe*lU{bz85JpVeT##}jK<
znWt20Q?IU7Id$n!s|bh<3U+J%4G>Tc9C*dVC|^SxpA7gGgrkUSJ9imcK`STDA>PyR
zp@VC{4aU$(U-baEfhc$Egl?`pEF_}+jFppLAd8b^sgO^d!gq-=$GBc!)61v1Eu_-#
zuD%^Z@=%dx&O4k>U1A`8iC%&rr%s%tck1}+yEtJR$)&bVB0wJ-_mk!=gfWN#3}GC@
zh+_n4YMsR-9$^Y=eEyG-Kpsgv;|H*b8I-75<K;Ng5+41gGzvivViXr9s+XP*Av|ZV
z7<=~<A4M?m1CrwYCOd^_SBbdE{@yg-5+@V4cmb*8KZif(I5M4lGW8L@RFcaD<kC3;
zg>>=^%Ci3hg8lwegw7DYp8ptvEVIPo_t|urWU`dHf(bmJlvOO?p(|kCYscIm@gd6d
e1VlN2Ay>cz?`xPf_!q#N9AV5)vZF-%F!l>&O3$tU

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/one/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/one/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..e2afaf0342945a97fcecb00017d0f82682b76b11
GIT binary patch
literal 1520
zcmZux+in|G6kW%j@!0M-iQ`;woj}`!VmEf2CN61ngEnbsijx4Y0&Snh&Lo-Eo-yMw
zB5z3Wh=h=Mfgk8gUO==_iB$1KB>sgTK-|`uv6BYSNayU^S$prb&zWEU`soFLS!~A9
zhbawL;|O8u9L6y%ml?T~G+c{8!<%xM)o?wIIHuxMZp1K$d8sbMv4|xNZwW*eEZg#y
z1j5<emVmPCY?}hTWy>}<+KsB|-ZQFoTKdaQ&8Tk~t|j%3QStVymOxM0vCU$|skc4L
zvFC~9wrzoA*0<ktO>={&^SLzvt=4v>(mizIWNO!OJb{GQiGROswi%Z!KQcZsiiEBg
zeG~Dc4a;6Jo8F#)An4H9+V-2>`Y!(a?84cKmWY+8ct-8<y3zD|((pDbX&4skAId%q
z&esilw^;F9%if*$Niy7Bww?MPH*0Hkco0x+b~@eJXF7YSvtJX4SDdz6GgmE1aH7lK
zr0iEm68!=Lr@eC`kIn6})$(-Q#4R1mSkZACs{*>DzssbKcaYI>2bqqeiz^}5G~Ctk
zF3LJyL0ZGQjt!8(K0lA&=VtYhS>qgfPg8d$p*lM|rYkU*eTkMJd_MPpv$a~c8%=ND
zzf07Wrc<x8hivY@@$}Zs9i~xTYj=;kl3kP3zEntMzvY<?f;nya2LlYtDZa-!c$|i5
zG&sJLU*=geOKHlWx{Zsx?R|VRKp4DB=;xZER^%?Yt5*&ozNZkv0N03b9KaxDJqW-M
zhN%fj7*`$^RYt3{eLZmuHGFV{(EUS%*Ygw4p@i^ZUIe?clz$FY;5%3pA_6}{n^V%t
zF-8K%w@^n9z6gu%fhSl@D?cK7jD*}{L?1oyEx({Q?+XF4@9o-Rf$hoP-;5rxD8+AN
z%Wq+b+Ay0sj~-;$$OvA=Yq&sGa=3&N#&83#;}$Ms1zFyk96mq+RZL<VQ>f!AKE(_^
zW8{~N{EEL1Nlb~&m+%o$GsGti9g3thLL1*UKF26?g_!GOKVz6V14;wmCHlr_8Aden
zr@V>d;tz~z&=Sei??{CZV_}yAzVRD}r!n~95#nU}T=@vvedQ4Px)f9j8(m>eIg!*8
zDUvTdMU(_SMXZokDHqZa%0D16k$;AsXXrh>0@EBk_`;&(CCNv2p4^P{olRmD*U8Z$
zpVl(g_}#@O%6PyRBw4u=l!!OTBzU?)Hiy|jl5vui5Rq=;3Z*ddW-&oYA!-46N-D9(
OC};dDI7x&MivIvOJugcD

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/one/TreeNode.class b/LeetCode/out/production/LeetCode/production/LeetCode/one/TreeNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..5a5535e1159f17f5eee068f66f3b114cf9212c88
GIT binary patch
literal 350
zcmYjMJx{_=6g`&~YHOj0iY6|Oz+guQjf)8hNrMBV`)hr|BehLxA^t4~W8&Zs@JAU>
zD}#BtpXc23?*0Dx`~q-|a}PF-U067AaOz+vuy!gF$V^~o`l%B1q9WJfvebHBJn9=k
zyELmcfzGYTO?5}&Xf}=+?uiS6$mDvyeNJ?_R7u9pASzOo#i}%Qy>Hsp+Pv_iSAn-E
zwq>fPrY3h6MYgR>kzZ}pPWkX~=A(^{!2iF8pkL!*rt($zkZg3yjjYi)#wD+@d7VY$
z96jLRpowl1g}H}AP?FgcEk1T8ACSq#J6dn7TIkaE8kK;0eYiMc4GjO-2=<yDu@1F_
Ics)1x1%akJZ2$lO

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/samplepackage/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/samplepackage/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..7015aacf7b75b4aad184766364f3ad67b07e9418
GIT binary patch
literal 433
zcmZvY%}&BV6ot=}0;Pf=Xyeu$y0A+Z7!zaSs?kLaiE%ZplRDTRQd-{26^SN3fDdIn
z0~j`J?#;PB-?=kCzn|X#uHd<_F>2%3g=O-IK<irPy1Ef)jL)Y6_FeI+1p0x_)kB>{
zs(g}B%E~Y(Vwp~5sg2$i?dnZ01Wtp6%;u?@%lKU;$`6aQu5^)4$jhY81-$V~Fq2E^
zr!r6cuqt()OxAv~Oh_2*X$v@uEl9u(i@J=}y*9V>{tYe-vx_ELwAg=xz+h+m7|m2%
z;f$}h`5|ByW}C51<ueQB=EVx)W8HQbO&c8OFm^WsaB)D@q3*F_mTw8OOzjKS^9qe%
d2Qa@4t~eYw5N|VxL-eT}0tUnx?;~mp!#{BJRNVjo

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/seven/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/seven/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..f6cd089f72cc8982a8980d6a04c093b878becef1
GIT binary patch
literal 2068
zcma)7T~ixX7=8}fWRtk0DdnTFR&81!A<(pxwwfS9=@&HwGzg{mwS*-shHPfDVFvvH
z&Un=eFB~sA-g#S{8XR#P$BTBxzvSn0Hk%Nz&Nw@B&U?=L{k+fa{`S|8KLfaqau@^1
zs+bI;OYU!kp&%QAhN&>##I!ulNZk#&%*y4aid)j)wp{Lnx!hGT7e*9Wx!eokE##!%
zyo{X>V*!gQ-WCW<nibQT67VIG%L2-*wP6UH$e9%*U*B0b>?M7@%$uH^Rn*JNx^2p{
zcd0mAW=$ZPs~NjSC0($}b;q<SS%H&P+pz2ny4(7$Vb}Dsz;ME|Te1x!&pg>=Zd>2g
z({w7QXKY*F%b7KY-imEm&SBiPy@0>w=*5p2zr(X2ujm!hTOkDcI`o~9)neV2sRjCv
zHndl5HFdtj)eSv)yzD6^8|koWCzxzrmi0<0Jy&szl3{11akm?1Uaxw%g$ib=qC0h)
zbxi(0RQ@ZpvZI?7c9U4^$X#%3vr@{s1J&&kM|A2rYNA;o6yx50#oH&m{i?TL^Y-fk
z!J0Q=fpEd9+ePEHDap~@n*2pMPYtILBZm%W>$cA#4sY6!X?O<(6-yf4#j=JK+}E&*
z2O8G!o`(1Ffk33mt`-Y4e2BP)kK}S1dRyPBLBlI}RmHl7A~rM_*wj$MmI_nDHprc*
zTZTKNh4pQtNT&IAB|*g;iFK&-CMcj%TQ?RqCCqakXOGO70rZUxvM$jvgl6n)@&Wl=
zt=F~$hMuSXw+HbycB;;v`%co^SGB4Fy@}4uUT~V)W@(EZC}m?)ZY+?maYu`Vy_#d}
zFp5>D-g_@hE4@gHI3$Xp?~tLYW4R-dJtRB1(oPg~tR}6Fm*SDFHQuA48M!JGmC4Z~
z=(H({bNoIH@Vf{2AS89TzQ|LWyWs90*@yU+LKn_(4Y-#vyhK@R8sIEm=1IuG(~8dG
zQ|^A=eSLtg)qVKp51?@O=Tpz%AA6k2C}XK72>bxGf#Aw$s)5kTXanJ|V8xVYn4<i`
zFVHedOnHLtrx+e{g$@_@EZtloqkQxCuR^Xr$#di>&bl6vV;+%~M?~5_9DB?f6}PWt
z^ie*8AUlh)qh9vZk2v8tk3n2O3PTvjFn<pTOe2ZA7{Ptsu45EsT!e*7uyGlm(CTws
z!56fAgp7;RL=y`SC!#{o<HRe7FB$y;v5Mj$vkY+rF?_}>aaNUJJ^j=*t&(l45n83F
z8$jSs^sDGnq5Oef725BZ_MZ!}AUUitgjklGq8!L5ox;4|K7h8W?DG#J1wRFjMq3R~
z$V)+`kWr)*l#*XcQK`)YT+!95snPEdIY5*nJ(&r{f}CGZCiERn#X=4AHqh5Vzod-M
zg?5}o0e_q!0@s5X-rZocv#jkV0lLNK4(=h30{@C@ScJ)MlBCyWvtj~!nWqqR54Iix
zKTe1wAr}aBoOuQrWx|CmjV!KG@-y}&T%#1AZjj@MLuHNuyvET6ndyWJdB_D?Qn`6E
N!b}3MGh-Jr{{V#S%-{e3

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/seven/TreeNode.class b/LeetCode/out/production/LeetCode/production/LeetCode/seven/TreeNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..991e7b03fa22e8c3571ae824e6ec5c9040f5a885
GIT binary patch
literal 354
zcmY*UO-sW-5Ph4Zjfv@pwXK2|k8Ka;=t1!!6bhjpT5{jSwcWBNkfy=E<v|1w{s4cJ
z_!4@NW#`Suo0&I1zhB<~ZgJ_u!MO(;Ll+|#V*$I8MnEhC9HU-Jfqt}CmCC|(q0};e
zR(AreLT|P#weNMN%Lh^?i)l=FWL=;a=}avTuZb$wGBL~yqCAx*mW8h4W6~+Nde2pF
z0{$vL6sel)n%r6C=1}T9yV=P~2JmqapoO+T_rDTqs~Mq@*(Q8Sb}FSNdoqo2&5Imf
zX!Em^7I1OWpx2<F@8c8#0lhgaK4xa05VNZfSnrH1bZEQHlp*Jh;9<-dv<(}*<4hlY
LZs9FBYx)L%jMqIr

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/seventeen/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/seventeen/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..f99cb0bd64c0d145075bf7019ac5dd5645774974
GIT binary patch
literal 2449
zcmaJ>-%}G;6#j1ZM@S5!$oi{^#TqRn7%a8Xf})5b(Lk`FSd5*rBs;JWb~DL_)_4Dd
zzO>_$+8JJau@5+7JG}L!Gkxw%U-}>P4{)sXySp*q;B+#%d+xpGp7VX*Irskl=H(WE
z3%DOeCoYDOh$4*7<uELV5jk86<Ffo-l*4EQS8%nPhptC)0~2A~6woi(j_r*KD1H5N
z0_wP1u>`vEwqs2<*A}h%thrd_N_XBZo7Fk9Zp(RVQT3MXhColgVXa$^XIai*(XBQ;
z+jT~Gq-;9l?pm#CdDggHFE?#ZAlz5Vm2&+#0nK(Q)^`Gewz6b0PN+mvExQf+Me5d?
zNodXzcS~}kv*?-S)hV;qO0F+k)tXfo=<q}4`tJ!u8=hJBazS9N>^2>S(#y^IO&LFO
zr)ig0i*7x@QOe~cWwB0|s^u(s%LH{N*k(*_`}<1O{g$wn?IrFD32lZsY)R73?fVg5
zN6lV$y;bW$7{}=^(F+{zE9F<rb#t(4I!l8^uTDZEzR+fUiI5JxXPcoKEfvYA=r-$R
zYr>XA=zObgM#hX`Ke}Q_;&cojqBn*<^v7@(8A`vmATby?9L8h}IouLBaLskShF3Rh
zQ<k^vRvKM8Zg(Ib!xW~&D8w*>J9OItUsznR%A~(*sraDbS!*ni+vJ83Fty#m8PfDf
z)-u=FhF_q_Q#+OEwHw2|Lg2`nxoVBOPTBPC+TJoP`Zyj{G5T`-du5|qKALwEu%&7;
zU6pDZeS1&!&xJ87S$!pt++kxo>+Y)6sz?B0!Yq4ko#kUA>3P>(ZPo;0ImfZ;<5jcK
zu!!u3-5FXj0s$vYr&6^V$>89~ULd<x-Z?n?pk}?teRpF7(vR%cq!nV^tX7M*XN`nW
z5;(nw-}|r$ocMn~oaAfK$#(+$3fW~G4{$cfui#fpy?}U5BZPw-b$>Ao`Lx6W2OL5V
zXDkU0bL3%h5E_5LN_tEC4WZDql2r{gz4ZjWXAN~oNgHZrfd5KCPPtWhsEUp4zf)(^
zTboeQTWUofc!ZSio_U00sq}#Fo7sf=BVvL5EcEQ5y1lXeXXqKTDL%riPbZ2Fe!EHN
zBq{aN9^@=bq+`T+i%92j1PeHhMXoLLQb|Um<hPHv><ErR#U%{1EHY`al-4nxlG3c;
z16m<wT0|TP=0Cwz1Ny(%7e+|D!l~DYiBmMB7`(TEJot;QVXll(7A31Cvbq%KDTWL!
zZRnYWtY&BfG#;ZXFe+JX1DZmz!qC-)^j0maZ*2de?yx?C2m_vC;3PSmW);p5=g0Vn
zFGU6^oa5RRT9V}?lSin9WT{ISZEj<2ZeuNOa`z<t6#hmTP3od!gqe<#l;qn9^$j9I
zh$MOL=K>$87SB9g6s|;5X(g^!Hlgh_Qk230Lj>}v52`otY(t5XK*E<fN*YIfZ$5gh
z$lo)v)HE4SJcjx_m5wJip=VVZhU#ZZvB%T}uKGEH);R9dy}*+fX$`Y6Mo9P)$z1j^
zoDX8QF(lg<l9VvOkVKl6!m|e3L&_mVP#~m|e2@cxLh*G1O6mBJlF6#^#1qWO;ZQok
z1w(y|$U}v#`wtz4wRD`z#dPABRt%ivDMNiqrw}j39;c1%=kcB55Bs{0v8>~~l-F6h
z8!Xx+(dUTq7Cu29SNSYXpn%)*vFC4&Z}mK8+iib_Ei%A%ma3N83Y6Lkl-dfES_<&3
z<)wP7KsWT)2n)66HM+t$*Yk>zBg{P1s@P8yM8+Qd1>yM@=*a88M&}i+Ft6%`c}*=$
z`E%N;%DGmU=6&BpB&+_6sG+{(wZtZ3JN*;Xa-Ns(9x;^I=J(0qYgY1`U9}u#cb#X}
z4z~Meyy$|y@?ywq+s8*hUSNgi_O~v&LO=P`UBF#_qxAohD$Vi4m>)&p8rR1E1DIya
A7XSbN

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/six/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/six/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..bd883f7629b07f9f79042f210f6fef9e7c1acc29
GIT binary patch
literal 2178
zcma)7T~iZR7=8}yX4z#?f{3QlQcKYQ!B|DH0jbtcG=gmqMEkXbB`k()X0u_+ZEt$f
zKhWt+uR5a_-q=osj!Zk9c1C8}E2qE5w$C})#L%&wPBQ0x_dV~|dEV#j{`TjSp8$-Z
zY~diz8kn@uBIP?4G@O+W=j3u;F7Fz+V8X;jxm=RVWeZnuRk}_|hievX*9~MX#AR?C
zH%v@pMmpS-1>UppK5_<T1!5Ck$qOe1T9bow0@?+C$rad}^-At^b#2iNW}U?%EnQhZ
z?-b{pz?09BQ43eRiol+1#rrg!^NZEc^GoA&F8h_x50)4mIO}duaf$*1N#!;hxb8HI
zj1Oj4opmS8m}2^T5I7rIuM#p?3w%GUCvA8Obc9i4E_Cwu1maEc%EVaHsV5TH-?ZPH
z-zW#F0Rbal4P+|<J-bi0QLdlxa8nXhWMcOrCRuc-$){0hqGl{Qr9yhD6uJdB7?;i+
zD$5P096@O2yh6zds{y;n{2zq=EwQ%dcqN`BdAF%@E)2X<VO&kt2@0ImzL#tZ=q18%
zB9bQ~IU31RkvtvAF@d&9G;9GY=U0Qgd)bpL>8O+7n4GPR1YRMTUd%Zf-M$x=24FUB
zVa~=pZrfPE9RXXCsy=@kchPU-1G#*Nj|_Zl;}fvLBJwtta7Wf+11hNAgpJp6*ub)l
z0#<BzShaBvMFVR#O7I0bRUc|bGmEQkp0v}-)yj&%kz^B!wY@rFo7_21!>e3cD~B8E
z0<mkY?7AdpcQT^)Zf~vVF0+Upc!d?p)^&L?#1zT=qLYX%OwHY@JF_f@I@O%6&L<{t
zmX^r$mo>{?TFZW!9Wj_UyXmaCjY{aQao?}9iRhkqe)=ZK5|T2mvnEd#`f4~b|6ns~
zA~?u`(615fpXZHeN4BYB?M}_iWm%|5w(jb@K~@~*E9)TNhd?WYBoWs`d`eRaN_}Vx
z;#(>$=;azy#vZ&%-L5&{HT3aGNCwc0!QvTZjJ7|v(Xz0G)*IW<DD~;#9q1#EL`D-C
zJvF?E*nDae##eZl(05={Z~GZ$Mo;M9!`i`7Dcg6@m(VlXh<vbrK*uKb$f&*Z%<<r_
zUlN+~zK`}OYJbhrem{zT`k(QisTxnwky46mN#&_qtcFEan;m(?V`&PCRbmBV*GAMj
zsdw|}Jp>~`IC=@i8|cR%-o!Bs@M|;3&&Ck0V;HxQ;=LL{o;#lt=Pz&^U*au%jT86=
zqj-o@c#Jdn5pQD$<9LR13hv1oq!HW%S5+W2@H?vv5b{p^iX%A6Nha_FN!FL0Zn1Vh
zbXEuZYl-}a8~!Q!k8rOS)^qe2XfdEYN4o)&|L);<{7^h@vR6rgG{1Jo*{kA+kdYSc
ztJ^Rav@LXIrJ_^ez|Dmim1(IMR5F^>+N7pStyAu1VoFu}#&GH}tZl?el&(x$qK)*}
zmodLXcf#Dn{!R33;(#P#t3v+-=?7etpJjC6GO@ox46d@nDP(Ys)-2Z?f3tj_-QpW*
zUZJ>L>zG)dWV{I{La~c;86{4Vz%!gcKkE!I%V~vTnsXRaC}w#6Gt^?-8{mZcVX(#l
b*6bs)cd=JZz*K0<3sSSBSV=I4#Bkzo#4_Pq

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/six/TreeNode.class b/LeetCode/out/production/LeetCode/production/LeetCode/six/TreeNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..f0dfb190f566e441266ffd2b8fafe6a55835de96
GIT binary patch
literal 350
zcmYjMO-sW-5Pg%Rjfv@3s#WmfvF*VeJt$s;LLt;cOYWPvwp-RLq)F-D@*si-e}F$q
zoWvev*?IH%X5RPD=NEumT>5Y@^kC!6#kq?S!QKl^pgF<O@}(qn<DEK0t3t|!d6svC
zR-x7#F0}7euF3~)9M2~S!z0%Ty;$XPQN5<JScz0~CX7ucbRr5>$H$~oZq$w!9SHu?
zR7ECds&4Kqjjl>%@|&&LivT_@0<_R31pn_K^y_-0MZS)n(yh$+B6~bZaLsBQR%i3)
zIktd{lLoy8iG3fZU`qC8u=sIi`T?3=y~BFr$U=v0w_zDDUkDFFj)Bo%H+n}-AAR1!
JN-${V!e66uJC^_e

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/sixteen/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/sixteen/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..41eeb6ebb949a37ce2bf8cd7491a48f2ba4edd69
GIT binary patch
literal 1032
zcmZuw&rcIk5dL2GZMQ8gRA3Pm5GrDS&{i+i2$C3#5mTs14N1d=rQP6SyGyoP0~g|f
z#6QBDnsD)=2S}9ku6O?#62Wh`7=khBn>RCWzL{@kwm(n5bphPR-54~aG~9|Igp@C)
zqqvQk815jgAtMl;w`|K>5Kz*YRROu^G)#ekvSphqoz{lwzBD$P^bD4ry3t%UT+6r5
zozi<{wf(oYwd0wlU939Ij%PXcoPb(4?8Ywd^x9HpiMM4p%pCziU2_f3vNs70t<e;=
zKr9G<?79XqO1sk%NK`$e{(9Ni4ytJwCcTznF?b}sR^Bq+7{#VxZx*Yb%Vcu_eZ%#$
z4*lm@Aksc($BG6kR-KMpH=kO5dx^iy3x3`>B8Unk|7|Od0VFkK<H%uFLq3iIij2G9
zQrXxt>)s_-b+_%AY)5fAe9(KuEvNW`tUYo!jTXl>6y&(<=AgFype9?E>7~pnrno_k
zn*|iGAw(%-w2Hh1Z#8=a@r6nVeU#zAsUc21-U~ni{j|7ZBq<3Ni%=N}yvubTjUC5U
z@`|j;lGJ6c`vKXUE(<)eQTT+xye|2pF4rpui1>PCUy6gXU-?{@?h-L-qonHUdpyYL
zDv_#OCvq%LgNMdP3{dImOyg%%3+pAhubv&8{m|uSQc(i>3nU3@3dw7v-A7x;AW|5{
zJzPbJ_B?Lj3C2*t1T0LV!`D69`<M>eeik4LxI&!7b36<*)o=HF6uvgZjNA}Wetv((
zZ!toj!rY6j<YPyP8HIL=exc!-NXZkZzmX6kdqQqeTql#>Hue}T89fs|j@3BKnp7$^
zRjri2BUC$rvOJqRgk1Ovb^H+Fi*=1~5kQuUnPsIsJ1X$cS`7Ng_A;`wamFOcuE%+l
VwI_H&lo8w{Q~%4DWK0NCe*j$~xQze+

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/ten/ListNode.class b/LeetCode/out/production/LeetCode/production/LeetCode/ten/ListNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..94064eda9161b8b13757a294d8db3013f6222ee3
GIT binary patch
literal 353
zcmYjMyH3ME5S(?Km>B1QfdHbROj0Bz1&9U-DUy{GLFv!t1Q(gJ<k(Suiy}gz-~;$5
z#GIg@*ty-&%-rtR_s1uIYg~kA;<ybTCk{>n3<8`98e5eMWG3*f-c^EbQfWI)%%++b
zPx?mCx;55RcN7d~qZOZf@`7Gste)4esV*N?nv;o>B2)QFmB!6~q+h+54L{fk!evpH
znSL-%+*uZRU75m8)@rLFggB4TLJ;8qZ9(*Z2|?e9rn$1u(?z=08TV`qM=M<MlqT=<
zSTqyi{6t}eIOH3#TTtONz41F_e7T1=mOUD8q&#$pF@wO)N0;^<vCjeqzcw;1lmX-e
Lh6;{2d5C`iu|Yc2

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/ten/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/ten/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..f51489a2de0f6cb15168250d4c44284cc1b9e86e
GIT binary patch
literal 563
zcmYk2$xgyh6o&sxfeM0%6F6%miV8NaTwvUoxB^^YOmugtRjRc$v^czwD>f!3CN5lR
z;#2q{4*#uSY??El|2w(wU(YW9wlI@K6cY)IBBvv-V^Sc#ZM$}`BcK&m4+WyT-ialU
zsoJhp?_4&m_JM3Vtc+AWQ#yyTZL7Rjj0P>+7Z|DrmTNRTrxVzoTM-y&Nq_gwRD0QC
z*sR)qP^WZd^_Y;BB~SWme;w9Or617wj&~!FZUoZ2sL87krejJV+3-4T)7rC@a=H)P
zIG5Klg&5)~Od}(Z`hSkVu<9F*bkB_a=DB4O5l-~UB)ZmZfJJD09`!{alpL+j%%B(a
zv9%|Nhp;_BtJ>gGCTLT?14v?!8TFB-Rm)w9DbdaKH^j8=`cb`BdPL+Ei^_#jt{2tH
zOzWlc{r5+-t97}gL4lS-M2<3fLZ=CtrJchP=264~%Dmh_A)H$Kh4l_07DLGJlq6O#
e%qYUCBC?D$j8HobE&d5j$0+{-2gg{9VEhMfO=jl+

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/thirteen/RandomListNode.class b/LeetCode/out/production/LeetCode/production/LeetCode/thirteen/RandomListNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..21a7b05617862b1e794c02bf8da3b2d8b6386705
GIT binary patch
literal 375
zcmZ`!O-sW-5Pg%RiHWJHRa?c2$F>J^^q_bV3WZR?O75F<(Jko)(oN~#@*si-e}F$q
zoWx#bnXfl*-t2t;e0~AA!Fd1&Cq8VPdN}hiAan|m$$~&Lf}`cm5H1q)swyL;j-P~H
zmg_`q%)DI6TY_7)2q$++D|637quDs+@W2E@lqfCd^*WQ)v&afY`bn9KA{CWt>OJW2
zh7B*>5rRcoSGk<3hTL70MQv26uUBF#LIfCw=)ffm|M?T4*HGg^=$H60TgjX+ut(z*
zSA3?!XWMKn!5;8%&_=(F#Cd>25JJwTu=p`D`2bBW-(kIRWueRds8xwruLmE;TmyqY
RHln>|z&)3>i2Kc4{}(&vMb-cS

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/thirteen/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/thirteen/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..15af7924acf11cd7f65d87274d826abac0578bcb
GIT binary patch
literal 1374
zcmaJ=%T7~K6kVsikG8akK$YtQ5kU*RQbiu7C^0?|wA3gDf{&O>x#Gq4wyCX;sUs5y
z4xDKG0H&I#B$_zHgsF+YVEhGR#C1*!jftAJ`>eBHXYaLl*MEKZ1Yi`$BZwer!VV*V
z!x4%BiBeJ=F>y2k6G<rsO&k+2PI$go85am9`ep^RGsQ($U|YuX-E6h6;FhmC3wdf<
zGsT>fpLNQfyw{al<&Jkxpe@6*Tyb4LHB-!2D_+qb6KKvAOOLKN{$jC^@$OXwh7t|G
zhCa&&$NK(h5s1k=mu{b_mZhtJ^&j7+T+J)%KIDU;id!hvg0wrXvnXKJ?E+DmRn|4B
z3=wH?AJm*<GZiOyciJg!wpnmIUtmY#dS=<V@1*jMzm%G(ls$iGOp)f4mn02;F$?HE
zs~)VMBwXEx>gTY4U}ST7i>6uy!l7YGATm>|mUHfeCr1$5BzHho5k(WC0z0>;|C7=v
zhLDgx!%>VN9_41l1-5T_Z{~`k6>S17jm9o5EW0_fr{|poH_w$wOsOV)#i>y%75lkC
z5iT4Mgpj3B#&}Ed6g>6*RfsnP0W?z@O4*KW#L|@xXu)=#TrIRwGFZH1GLyPj$<NTm
z>*Tb(2Kyrd^Y&W=SD~df0zGS6+B@i$c9>Es_?=$a_^RA3so>9e2cu#8o}@OdDXA;J
z<CY9d8@5GH-7?nDV)3Ak*A;{<T_`<E*!Ut7rS+AKbxV8A@`9=*AG?WnLPH1J+l3JJ
zu(iFg(8<p}^q>p<<Y^Gy80Kvh2Qh|2m_P!Tk;EKq+$3MOa1=RuE#nwUoLZIMkLmpc
zX*^}bGn~K+oL1Cb;VTwD?TGW;PQJc_D9G3W;yCLdd39nX>Y$GQ13YI;oTHe-Syn1z
zZ(^MF$2o>QjOjwy_z7VmU<>OPXF<g8Pjpl2KlpZ-opsj6gl~K?%%~|jngHjLkw7Du
zmcSs$N?;PCHHktJ=}DWEeuO!{ics3HjO2TS(`Ila)Yy}LwNw*Kf1Z0W$r7i~iwmUb
zBB`0hNw#nf^R!%3gxshVLb|(HP#CA`Ew_@u{i@~Nq^6rF$UHqbpqfvSgdWxWNsg?S
aduTAL#sS6I`6Sys#36-v_AzS!{l5WZy$f{!

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/three/Point.class b/LeetCode/out/production/LeetCode/production/LeetCode/three/Point.class
new file mode 100644
index 0000000000000000000000000000000000000000..95dd29d3e137263e45244e2c4808f62152903591
GIT binary patch
literal 444
zcmZvX%}T>S6ot=i+Q!z@#Qyoa=(2WUmo5}HqEIL*R0=L9b+A)n0x=bREEgiU@Bw@%
z@k|rMg^PRU-ou>l&U}4;d;&PaZXFeLYAB;?Wy{63iyeVHvqr2JLG{GMCOZ{4{e!8X
ze3sm4fj>5}zFa<pI=xY0M5j4UW-6Mh)Y!Q&%h}vK3L4{Vo@zb3PE4E~3o8B5$ihUi
zLP33!EYq33Fc#F9B+)W6Nqo3aPs&3Lbq`gz9@gLr*8iXcfxR<~RD3_Y3Kx2op~sI@
z_`4E|DJpD`Y8}Er2D@|4!qXqTLk7+pN>-fL)kTlmBna4``iuqaHqoHt<uT4aCyNXU
r<Smg7ogBGmk^BE3TST@Q>k!dhA$xi37wL1ATdZlavoCECTtfQ?5#~M7

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/three/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/three/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..e8833f2b7fb2e911b5f210547e3c2c81474a3542
GIT binary patch
literal 3162
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
H7#IEvdg8?m

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/twelve/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/twelve/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..e7a2e34373335d4ac531faf8076a0ee4a2e9c6fc
GIT binary patch
literal 3291
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

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/production/LeetCode/two/Solution.class b/LeetCode/out/production/LeetCode/production/LeetCode/two/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..38803970bbb9f075d490582139ef004b5df35716
GIT binary patch
literal 1937
zcmZuyU2_v<6n@@hlih4LZP+%cK`AYk(lnu=Ef#1>MXHrbzaTZ3g32~s+J!WU$p*#o
zQhx+qdea%l8@(uujEpnh`7gZEOE2+biqE@ACPA9X**)jHXV1rTo=tu|`0*)#bGV};
zj*N;~9X@0<T+|W4oQ5|wT+;BC^j=mmuS3V%^5`9@ElBsfQoEvJQNw#0u4-6Pv8<yH
znGja6Dz!Bo*Kl1$Rv<X*lpJ?Xz(1PE2`KaBEnA>x$tl?@_1#Uox^8V2=`oke1*@2|
zs*bdqPQ~4EY69I$?x*E+wp^^cPPvp3Q0@Cx@%q||Ky38p(p~Gml`dMP?R3_yI;HJQ
zVo^XVSL~|g+LHpk9TAHq*WR|P%+U&%V2@S1Rxi2&A;-0M*UR_pl5FUuyaEBIv}J!L
zAXp*j%0RZ)dq@icMzeveYZdMZ9BHKE1Vy$<7h6zj&gUFG_TuOdDy{KH{{PHuM^CLu
z=9nn#Wn8u@9&Rd9%)M(loZ@hN<RYx<HhT|vLlBKx6I}s4Tdr3N_JSkV5^kYBF3~V>
z6t8l79y0Awh)2@EI^L&pnleU78_3}X=We6e?AX8u$Q#(eO#`>&<wJZVeIE-%+QE%g
zG7%RjxFaz|NIPku;<f<`n+Aq(LPf#A7T9n{iq*}#c7a<B+Mm>|B8QERcHq}I%_KHR
z%}Ti<&^MZR`IuZI)#~=@9f{>)XGCiO1aHTx?KFr@mP_(EB{wG@BhHn2ZAW0_u+oQ>
zJJlK3;&Vq}yK2Xz*#|WemxGk+oHyDCcgpECz78&v*w!vt((9r7qMP$oWKfY@Q8-_Y
zX!h}!L4N!Ya^JkZMk~#`;5{(*2;zGxJ{;pU=s80epl&n*a2$iQgj@`-eAxFDqr2$J
zKY=g*2>#{d(>edN5><|UBQ7SR%H&MIRN{es1ir?Q8Ek6(rrOlPrsio6@jSJU(9h6k
zf-Ob$KStLK&u2ouX+0j=hw&}Tqd*y>q$vxO5sLIpH}AQ4$W&PIA*TJ)`X0{E4tn;8
zBJDxis%OUn(vHy9JUbYi)}y*C;!xzrPmySxq0CcqaXuN2GhO($*WDgw+pevqE75lC
zG+nW_tJrk;Q*oB<zOjdJDjs-@9%+23h`obfnh>zccPy%SEo>l0y$c$`yhgaqBiv#y
zE>pXTC|}bU-@ShPLGLqe_a6+1E*ux#7!m_GA%-w4CU8=mMM7kd6m$GFxq^sT!IZb;
zTL>}FpLiX^T>d(K$4P1`bN)t%hgtWi7{@7$B7kmj2?;Jik*jagLTX8*NDNI}!)c65
zYA}16aefa#Nu$Qu1kWZp%>sH3(5=EJ#J`wQ5qXY9bgAf5rA04YD)iPjLZ0^Y^cVxC
zY5oQC8A5-{Z-AYj#TyMu;tO^q*EXsBgh<|R9?9kv)6C{c#B4rj_Ga^{sb-g+ppS%&
zF8_d7D!GsTeZ0~pzbPl<pXmV3bM_0Ez>J5{U?VfBmg4yUkw526Ji=GxJYNnUd$_<8
HA7=gooYaY}

literal 0
HcmV?d00001

diff --git a/LeetCode/src/samplepackage/Solution.java b/LeetCode/src/samplepackage/Solution.java
index 757e974..62a9eb3 100644
--- a/LeetCode/src/samplepackage/Solution.java
+++ b/LeetCode/src/samplepackage/Solution.java
@@ -5,4 +5,9 @@
  * @date 2019/4/10
  */
 public class Solution {
+
+    public static void main(String[] args){
+        Solution solution=new Solution();
+
+    }
 }
diff --git a/LeetCode/src/seventeen/Solution.java b/LeetCode/src/seventeen/Solution.java
new file mode 100644
index 0000000..226ead8
--- /dev/null
+++ b/LeetCode/src/seventeen/Solution.java
@@ -0,0 +1,103 @@
+package seventeen;
+
+/**
+ * @author dmrfcoder
+ * @date 2019/4/10
+ */
+public class Solution {
+    public int canCompleteCircuit(int[] gas, int[] cost) {
+
+        //remaining为二维数组，remaing[index][0]代表车从第index出发到达index+1站后里面可以剩余的油，
+        // remaing[index][1]=index，因为后面要对remaing按照remaing[index][0]即剩余的油量排序，
+        // 所以要把原始的索引记录下来，排完序后直接从remaing[index][0]最大的值对应的remain[index][1]处开始开车即可
+        int[][] remaining = new int[gas.length][2];
+
+        //gas[i]---->gas[i+1]  cost[i]，计算remaining
+        for (int index = 0; index < gas.length; index++) {
+            remaining[index][0] = gas[index] - cost[index];
+            remaining[index][1] = index;
+        }
+
+        //按照remaining[index][0]对remaing进行排序
+        QuickSort(remaining, gas.length);
+
+        //由于上面排完序是降序，所以这里从后往前遍历
+        for (int index = gas.length - 1; index >= 0; index--) {
+            //如果剩余的油大于等于0，说明油足够到达下一站
+            if (remaining[index][0] >= 0) {
+                if (helper(gas, cost, remaining[index][1])) {
+                    return remaining[index][1];
+                }
+            } else {
+                return -1;
+            }
+        }
+
+
+        return -1;
+    }
+
+    //模拟从第startIndex站出发，看能不能走完全程
+    boolean helper(int[] gas, int[] cost, int startIndex) {
+        int count = 0;
+        int curGas = 0;
+        for (int index = startIndex; count <= gas.length; count++, index = (index + 1) % gas.length) {
+            curGas += gas[index];
+            if (curGas >= cost[index]) {
+                curGas -= cost[index];
+            } else {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    void QuickSort(int[][] v, int length) {
+        QSort(v, 0, length - 1);
+    }
+
+    void QSort(int[][] v, int low, int high) {
+
+        if (low >= high) {
+            return;
+        }
+        int t = Partition(v, low, high);
+        QSort(v, low, t - 1);
+        QSort(v, t + 1, high);
+    }
+
+    int Partition(int[][] v, int low, int high) {
+        int pivotkey;
+        pivotkey = v[low][0];
+
+        while (low < high) {
+            while (low < high && v[high][0] >= pivotkey) {
+                --high;
+            }
+            int[] t;
+            t = v[low];
+            v[low] = v[high];
+            v[high] = t;
+
+            while (low < high && v[low][0] <= pivotkey) {
+                ++low;
+            }
+            t = v[low];
+            v[low] = v[high];
+            v[high] = t;
+        }
+
+        return low;
+    }
+
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        int[] gas = {2, 3, 1};
+        int[] cost = {3, 1, 2};
+        int index = solution.canCompleteCircuit(gas, cost);
+        System.out.println("startIndex is: " + index);
+
+    }
+}
diff --git a/README.md b/README.md
index 29278fd..ed0cbe6 100644
--- a/README.md
+++ b/README.md
@@ -158,6 +158,7 @@
 - [single-number(出现一次的数)](./LeetCode/Doc/出现一次的数.md)
 - [**single-number-ii(出现一次的数2)**](./LeetCode/Doc/出现一次的数2.md)
 - [candy（糖果问题）](./LeetCode/Doc/糖果问题.md)
+- [Gas-station（加油站问题)](./LeetCode/Doc/加油站问题.md)
 
 
 

From 4800fd9ec106b1f8a43f6d48766b9d268c4dbd8a Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Thu, 25 Jul 2019 21:22:54 +0800
Subject: [PATCH 23/24] =?UTF-8?q?=E5=9B=BE=E7=9A=84=E5=A4=8D=E5=88=B6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...76\347\232\204\345\244\215\345\210\266.md" | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 "LeetCode/Doc/\345\233\276\347\232\204\345\244\215\345\210\266.md"

diff --git "a/LeetCode/Doc/\345\233\276\347\232\204\345\244\215\345\210\266.md" "b/LeetCode/Doc/\345\233\276\347\232\204\345\244\215\345\210\266.md"
new file mode 100644
index 0000000..6fcca10
--- /dev/null
+++ "b/LeetCode/Doc/\345\233\276\347\232\204\345\244\215\345\210\266.md"
@@ -0,0 +1,44 @@
+# clone-graph(图的复制)
+
+<center>知识点：图</center>
+
+## 题目描述
+Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.
+
+
+OJ's undirected graph serialization:
+Nodes are labeled uniquely.
+
+We use # as a separator for each node, and,as a separator for node label and each neighbor of the node.
+
+As an example, consider the serialized graph{0,1,2# 1,2# 2,2}.
+
+The graph has a total of three nodes, and therefore contains three parts as separated by#.
+
+First node is labeled as 0. Connect node 0 to both node s1 and 2.
+Second node is labeled as 1. Connect node 1 to node 2.
+Third node is labeled as 2. Connect node 2 to node2(itself), thus forming a self-cycle.
+
+Visually, the graph looks like the following:
+
+复制一个无向图，图中的每一个节点都有一个标签，以及其若干个邻居节点。
+OJ的无向图序列：
+节点被唯一标志
+我们使用#作为每一个节点的分隔符以及节点和其邻居节点的分隔符
+比如，考虑一个{0,1,2# 1,2# 2,2}序列
+该图一共有3个节点，被#分隔为3个部分
+第一个节点的标志是0，连接节点1和节点2
+第二个节点是1，连接节点1和节点2
+第三个节点是2，连接节点2和节点2（自己），即形成了一个自环
+将上图可视化出来就是这样的：
+
+![image-20190725212103586](http://picture-pool.oss-cn-beijing.aliyuncs.com/2019-07-25-132104.png)
+
+
+## 解题思路
+
+
+
+## 代码
+
+[这里](../src/n/Solution.java)
\ No newline at end of file

From 66cd4d10de0165c416b963f99c3288cea542cc2b Mon Sep 17 00:00:00 2001
From: DmrfCoder <xuefanggang97@gmail.com>
Date: Thu, 25 Jul 2019 22:50:54 +0800
Subject: [PATCH 24/24] =?UTF-8?q?=E5=8A=A0=E6=B2=B9=E7=AB=99=E9=97=AE?=
 =?UTF-8?q?=E9=A2=98=E6=96=87=E6=A1=A3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...71\347\253\231\351\227\256\351\242\230.md" |  12 +++++++++---
 .../LeetCode/samplepackage/Solution.class     | Bin 277 -> 433 bytes
 .../LeetCode/seventeen/Solution.class         | Bin 0 -> 2250 bytes
 .../LeetCode/sixteen/Solution.class           | Bin 2361 -> 1032 bytes
 LeetCode/src/seventeen/Solution.java          |   4 ++--
 README.md                                     |   1 +
 6 files changed, 12 insertions(+), 5 deletions(-)
 create mode 100644 LeetCode/out/production/LeetCode/seventeen/Solution.class

diff --git "a/LeetCode/Doc/\345\212\240\346\262\271\347\253\231\351\227\256\351\242\230.md" "b/LeetCode/Doc/\345\212\240\346\262\271\347\253\231\351\227\256\351\242\230.md"
index c9eadad..ae0cb47 100644
--- "a/LeetCode/Doc/\345\212\240\346\262\271\347\253\231\351\227\256\351\242\230.md"
+++ "b/LeetCode/Doc/\345\212\240\346\262\271\347\253\231\351\227\256\351\242\230.md"
@@ -1,7 +1,6 @@
 # 加油站问题（gas-station）
 
 <center>知识点：贪心</center>
-
 ## 题目描述
 
 There are N gas stations along a circular route, where the amount of gas at station i is gas[i].
@@ -18,14 +17,17 @@ The solution is guaranteed to be unique.
 如果从某个起点出发可以保证你开着你的车绕着赛道走一圈，则返回起点的加油站下标，否则返回-1
 返回起点加油站的下标。
 
-注意：给出的实例可以保证解决方案是唯一的。
+比如下图：
 
+![image-20190725222358833](http://picture-pool.oss-cn-beijing.aliyuncs.com/2019-07-25-142359.png)
 
+加油站上的数字代表该加油站具有的油量，圆圈上的数字代表该路段需要耗费的油量，那么小车该从哪个加油站出发才能保证顺利走一圈呢？
 
+注意：给出的实例可以保证解决方案是唯一的。
 
 ## 解题思路
 
-贪心的思路，计算从每一站出发，到达下一站后车里还能剩余的油，然后按照剩余油的多少进行排序，从剩余油最多的站出发，进行模拟。
+简单地想，我们当然是想从第1个加油站出发，到达下一个加油站时车里剩余的油尽可能多，这样车里剩下的油还可以继续后面的路程，所以，采取贪心的思路，首先计算从每一站出发，到达下一站后车里还能剩余的油，然后按照剩余油的多少进行排序，从可以剩余油最多的站出发，进行模拟行程，看最后可否走一圈，如果不可以，则换下一个起点。
 
 
 ## 代码
@@ -81,4 +83,8 @@ public int canCompleteCircuit(int[] gas, int[] cost) {
     
 ```
 
+可以求得上例中的答案为0，即从第0号加油站出发，就像下面这样：
+
+
+
 [完整代码](../src/seventeen/Solution.java)
\ No newline at end of file
diff --git a/LeetCode/out/production/LeetCode/samplepackage/Solution.class b/LeetCode/out/production/LeetCode/samplepackage/Solution.class
index ebc48befa7b77dd0b539eaf9a4fe0fa4bdb0ceb7..8d986fa1629e064f32740e6de4c3aa37a9bb9b4e 100644
GIT binary patch
literal 433
zcmZvY%}&BV6ot=}0;Pf=Xyeu$y09B}7!zaSs?kLaiE%ZplRDTRQd-{26^SN3fDdIn
z0~j`J?#;PB-?=kCzn|X#uHd<_F>2%3g=O-IK<irPy1Ef)jL)Y6_FeI+1p0x_)kB>{
zs(g}B%E~Y(Vwp~5sg2$i?dnZ01Wtp6%;u?@%lKU;$`6aQu5^)4$jhY81-$V~Fq2E^
zr!r6cuqt()OxAv~Oh_2*X$v@uEl9u(i@J=}y*9V>{tYe-vx_ELwAg=xz+h+m7|m2%
z;f$}h`5|ByW}C51<ueQB=EVx)W8HQbO&c8OFm^WsaB)D@q3*F_mTw8OOzjKS^9qe%
d2Qa@4t~eYw5N|VxL-eT}0tUnx?;~mp!#`{GRN4Rl

delta 118
zcmdnUJe5iG)W2Q(7#J8#7zDT&m>GE48Ti;4_$NvwPCP8j%)-Dr@v)&FGf<v^fe{FS
z0zi@t$kPY&85mf#wlgqp1PU-QumedppfCfF#Q`LFz-(3qP6jR@kCA~JNHQ_-001Pq
B3*rC(

diff --git a/LeetCode/out/production/LeetCode/seventeen/Solution.class b/LeetCode/out/production/LeetCode/seventeen/Solution.class
new file mode 100644
index 0000000000000000000000000000000000000000..caa71beb41e150f02c81114a30a231d3a9477ec5
GIT binary patch
literal 2250
zcmaJ>-%}G;6#j1ZR}z9Cuv#>!C}<%Ip;Ap-R1~plG!kemnr1q~l5AlyB$=?G_1*uV
zPaU7s2VQ*9hd5I^y!EA>K6j=s{SW#FI9B@I-89(Zbarz0<eYQQ{l4#<yFb7AVF$n&
z6r$+E1p_CdFfb#Ri*mUnmstas<@<tM<|4R)&kS6Rq6-(oxF+A%<&u%hjVNv+Yv7iE
ze%`IR-i&}UI<_RB&eh6}Ku^}KI`hqq6{m6AUa8R2m#vlT%97o1<^Q%*_14@?fr0F%
zv*lDh$Ei-{Yn7(w)~e^YrDRv<Y8&;6<2iF~qttXg0b{h7DQ3np0-9SbJKqWj+RCcU
zI-w#>wN%?=UZmk{*o0PHWwa;*-FeS0-MeMi+lT9GPNnWN1j2sF%-EL#(M`{8c$uKE
zR;o3tETxy4jcc-gWU=X%?&WKZ07o&Ck(9+2Qz}k%)mtN|#URX@4Eu4VQu~Im*4$Ob
zg@m@iGh9j1KikhEzHr^$s(JUE`v#6NU!oT{G+NBA+gtWz#jdVS=Dh|9o%4mZ8>@uW
z|Bf(AZMIb;qkOH|C^=VM*@W(Y)J@5nG4x{~hA|{#7{SRHCXk9@3LjDW{SArX2#y+<
zk0FNzfy4hrb-C$Q%2LjrJq?H4&FP^S7V)`U@-f`T7Y3GMxP!X_y?Z5cE9*{)(!Ax$
z-{16{4K}aVWWWqmaBGtbl)$49j=jMd(d~NOsg?yMM&F^+K35wgH^xUZWB(Hld$mAp
zPUq<UL>B1x(f=C|$FnZsRoFT6U4WKwoVTlwml1rk2nM*C{5Q$B;9E<+fOtkDghO0)
z-)Z15?O2e2_b|wRLiU3zH;aSN_yFtHj`kBmp?M{(nyR()7()}LI;B{qni}V?oRfbU
z$~{oU_U<3a32UbX#oAHJa>GL;{q)pB3?{8{KR4Ba`aNQS{WSFSfx5fB`&;NKPg8t^
zX>`->Mi{*$c8~=7I8wbNbO>o8oh8Z}h@*f6mNA4C`qpsLXEZ~8U7Wo*V=B&Lyls(5
zo29hg$1$JzI(HwVE@9R<juSk8m?xXi|3a66ka&gR*NBN>8d407bRZ9YXR1NZEM-yB
zS|Y7Wah_nx)GSj^EvGe88>jIIJ%Le9YunHik`<<|E?YbGw7$LjtGdVf6e28`WMPXO
z#>sbryi!Cp$@Mfor0*im`Yf;W@Cdb#EOiN^!)><1ZMMx#Mo%$M;WL8|d|h;$!zeAy
z=i3eS4I)B_5%N61a=gE7o>`_S^hA@E5?9MDXnTVcrEtKf1TyV|8VWKyP@*Jq!k0Np
z=m|fY--CAL?^xN_G@f__^;y!2CtA?cDh*ThPfBve)Ma}8GlS7M;?tes&Wp5W(Syqr
zX^u3m_!!OvH9HtaIv7SMV}N0VQc5{`*yz)=R9^%ILMq8`RRB;Z3`kGWiccx2v>H!5
z#)4e>tppvW`UsH+3P<-(CQNHqobJ4p7}WAXlH6sgPnZ<q#n_j$z56V_*ZgT;ciGk(
zyp%UN;8_l2j*VNOc8kQB$0dI2u40MNJM`S8Rp3+XjQuI{I?ZvGsunv66gvtOI|>xr
z3K*<-rlUX~^w%(iI`A4j2F?z=;<b}Q_Hnyozfcfa+j$A2@B-m%ul{4Spy;`Rs^tn=
zI9JeV8%C}W)^oRlAOk9$8l5_S2JNtso9CCHg-BX`j_6Btu~@9HyM+U$+ConYy)7Kv
z8?&J0%e<pDuipwAUZO~4K3~7patEJq6v3>oIF5sae3F96dmiGBVgD{D+;_D7JrKMB
I@{4%>ZyyJUdH?_b

literal 0
HcmV?d00001

diff --git a/LeetCode/out/production/LeetCode/sixteen/Solution.class b/LeetCode/out/production/LeetCode/sixteen/Solution.class
index 1c515a6b7c7a7c2b7653c50b785ef57c2342640d..bc830e9ac1c5bbc2d85036048d6f8561ec58422f 100644
GIT binary patch
delta 490
zcmYL`%Ps>^7{`BS+B)qR6h+;Nx=*Vm!9uWMArc|6@&FbMX%{rH!a_n~CEa)l3l<d?
z9>D9^Nr?X$5|hk#o9}-)XI{E)lC$sMuW!I2^FEfmW!%Rj@4`fiNv3?JnX$~?tv#4b
z<JKG%lB5jjlgioY;bFDBUpua!R%+FN4$_t|pg_?w7f_<ySn{fSo`~HO!yv4pudb|Y
zloR1I=23-5t71zuv;?Yy-v!!eS7)4nqTl%N?l0W#x+Vw})27u<tNI?g$dh4#K9<$5
zGRP)F?2@CxD0O{3SAWGsq_GttOLPhsXPcF%N{ILRPuEr5Vl>jZiuiS)6)x%3FedU1
zNjY#<pe**Ac4O%``S>S^FWQU=KV>e(fUG$C56N8BJ9s9xQ!F%zuRoC(Zqo992faA`
tP^T@5a8Axk`V-~IZzv&{(g}u@(=zevEh~wfUQaQ}hzz;w9@UP=*bfB|G3fvR

literal 2361
zcmZuzTT@e46#jOyPfilTMdT<*Vk@OK=8(`@n<8kef|no~G-74w0|!Xq2qZKY)IQkG
zl<9Rk!%QFhqUa1SzSx<{OzZI4X<s|-f9P8uJCvG!`<xK$WsrT=-g~XJzxC~JFZ}7*
zcbfo?;bIUCI39!#{c0Fc!wEH<)R9tOXYW)1Z{c(hXE3N^NWgc(&fDdbfH!*Nx_}%k
z%;W@`N9=s=a%FKUSG;CTEpVlEq%dtQT(^q0n%5R(dCo4Wy^?*qoXh2VvxS99*)HS<
z1hi=@KXZrQ=tTNRnqNCVle;Y-XzN9*Z0Bbg>Y3nF<OPC``{`oQVvM&`Srll@maXae
zOV*NenvQm&oy#pO<%$g9ubi?<L>5q=L3J4G6!2fE*wgccV!3uSi_)%Sow-gZ>9i_S
zEc1|s!YwA5vuEeHK=;6?RV>>IJ`uXE1m|C}mkZ_j9AO3A)6Z4t;E$#!_@gTGFBNlx
zg-V_&<f3JBb6<2~<fgT3^)6WX+1_lq$YKW^daa_Wdhh>iGf%0;9^qJIBwMHyr*r3Q
zMStTCvk8?qgb*4-cnRGhyo|#knCJ;1fnI@@e_urid(o!jYzXIYUdM$H(io=SF22mv
z&D=D>Kev><Q!3|p1>Qo18-`nqUFaQUC1uu=vle;9dz~ErTqbo(%4vZ#$SBFiAxf`-
z3I+TS3OL6m&U*P3{A#fch{rTMXy)j17In1H4!I84gI3OXAlf)GSPVj=C-8~6c{2Po
zcscHs8JU!ZG&k1}GYy&GubfFdL~GoT{6||(X4c_Xc4kG2_3AHibCb(S#%ME1&CtF^
zpJ`}})Z`>1!*Ndd%gF;Y({OF3Q5m(wWKynZ)%EI+hI~XQUI%{485=kYL1(QEgln*v
zE*9|`3rKQ)0{bz9c4W{28wXH97<V~e!9l0&3yf^ybsE?QiDC3RmZr+BQK78;jNlD1
zs)K$W#(c<J?OYkcAUd7cFk{-GKSPty5fNQ-3))|36e70869muOA#^`81n7MuW^TYk
zR!wgrMMlkjtwY;P`n*Zq&<)=j`Z_d2PbB?@Kk^W5Br<Hs$&)Lds^L$qqm9e=(DdBe
zicYG32=6j<#;NfzFYpyAB1)c)kh2&qlQs8{r8rqi;5Zd>3a{cUSB7yEm+(49>35yG
zN*pN)Aj+Q?SgBtjuXA&w#*Lr;E;k{J;6?hWJ4#cLidV(WA;>C8^XuqR{0N67igFv>
zVhb&Q5Tr*vGgoz_Rn38hnCVs8*?@OfxIt&DA3+Q__|%=ywT`NxhRUO!Y%SqeOsMX)
zI~=(W`8Z~VBO4&=G?ZkSUujuRa@9G>)z|??`YA@9qIH@zonf7W1UlrLe9X;RKe?Ms
zE3NPx^5x>{ChIOA207i~!wcafY_^jcz&}ZpdS_#1m=7f!S;L4L_Lz}`A@3uw;^hPQ
zU2SS+n2Q-RVrUuHB}|tGbn#FC|8ZHbe*2sz`l&|XJaJzje`zu`j0kVM3zvyFLq%NS
zE4a!(UDv3GF<hhyM)5YX7_V!gi<(iDC_cyPwU5<nAFJ0sR;yiOj(ENH7WlTI3E8@h
zX3@IEmg8YY)umL!8DL&T#A>I!2TeYTcgh)=iE-?SZ$L}R9-4`sPR;E(oWzyw^qi}^
zd-u?yBAq>UqdwZI^N`B8YALG2%p}(6q>Oi*@ak_nJCljE>aXk7pV@xYVeCKu?L4!@
zImcdblf7r2x4uZV<@vvZCF<lovRNi)6|%OBcX10PypNCY0lsAK*m+Y~zB$!-G)CWc
zUX4_B*BM=P-jq_)s-tM7@>RyD&ZFMc9_acudPK)Iq|iFHD9-?&@X?y0?ov@I;bGs?
z;5fVXxb$YmH7zspJ$&OE&@c6vPvB2|gFxg7g1gVlz1WWl^HU!68C%!qEbR*icFfJl
g262p;TL|85j_tg<H=K(+$QF_0It7k5>El7)-$N^O?f?J)

diff --git a/LeetCode/src/seventeen/Solution.java b/LeetCode/src/seventeen/Solution.java
index 226ead8..f78572f 100644
--- a/LeetCode/src/seventeen/Solution.java
+++ b/LeetCode/src/seventeen/Solution.java
@@ -94,8 +94,8 @@ int Partition(int[][] v, int low, int high) {
 
     public static void main(String[] args) {
         Solution solution = new Solution();
-        int[] gas = {2, 3, 1};
-        int[] cost = {3, 1, 2};
+        int[] gas = {3, 2, 5, 3, 4, 3};
+        int[] cost = {2, 3, 4, 4, 3, 4};
         int index = solution.canCompleteCircuit(gas, cost);
         System.out.println("startIndex is: " + index);
 
diff --git a/README.md b/README.md
index ed0cbe6..01f6626 100644
--- a/README.md
+++ b/README.md
@@ -159,6 +159,7 @@
 - [**single-number-ii(出现一次的数2)**](./LeetCode/Doc/出现一次的数2.md)
 - [candy（糖果问题）](./LeetCode/Doc/糖果问题.md)
 - [Gas-station（加油站问题)](./LeetCode/Doc/加油站问题.md)
+- [clone-graph（图的复制）](./LeetCode/Doc/图的复制.md)