update-readme

Author: DmrfCoder

README.md

@@ -8,15 +8,15 @@
 
 - [从尾到头打印链表](./SwordToOffer/Doc/从尾到头打印链表.md)
 
-- [重建二叉树](./SwordToOffer/Doc/重建二叉树.md)
+- [**重建二叉树**](./SwordToOffer/Doc/重建二叉树.md)
 
 - [用两个栈实现队列](./SwordToOffer/Doc/用两个栈实现队列.md)
 
 - [旋转数组的最小数字](./SwordToOffer/Doc/旋转数组的最小数字.md)
 
 - [跳台阶](./SwordToOffer/Doc/跳台阶.md)
 
-- [变态跳台阶](./SwordToOffer/Doc/变态跳台阶.md)
+- [**变态跳台阶**](./SwordToOffer/Doc/变态跳台阶.md)
 
 - [***矩形覆盖***](./SwordToOffer/Doc/矩形覆盖.md)
 
@@ -26,7 +26,7 @@
 
 - [调整数组顺序使奇数位于偶数前面](./SwordToOffer/Doc/调整数组顺序使奇数位于偶数前面.md)
 
-- [链表中倒数第k个节点](./SwordToOffer/Doc/链表中倒数第k个节点.md)
+- [链表中倒数第k**个节点**](./SwordToOffer/Doc/链表中倒数第k个节点.md)
 
 - [反转链表](./SwordToOffer/Doc/反转链表.md)
 
@@ -46,7 +46,7 @@
 
 - [***二叉搜索树的后序遍历***](./SwordToOffer/Doc/二叉搜索树的后序遍历.md)
 
-- [二叉树中和为某一数的路径](./SwordToOffer/Doc/二叉树中和为某一数的路径.md)
+- [**二叉树中和为某一数的路径**](./SwordToOffer/Doc/二叉树中和为某一数的路径.md)
 
 - [***复杂链表的复制***](./SwordToOffer/Doc/复杂链表的复制.md)
 
@@ -56,9 +56,9 @@
 
 - [***数组中出现次数超过一半的数字***](./SwordToOffer/Doc/数组中出现次数超过一半的数字.md)
 
-- [最小的K个数](./SwordToOffer/Doc/最小的K个数.md)
+- [**最小的K个数**](./SwordToOffer/Doc/最小的K个数.md)
 
-- [连续子数组的最大和](./SwordToOffer/Doc/连续子数组的最大和.md)
+- [**连续子数组的最大和**](./SwordToOffer/Doc/连续子数组的最大和.md)
 
 - [把数组排成最小的数](./SwordToOffer/Doc/把数组排成最小的数.md)
 
@@ -68,8 +68,6 @@
 
 - [第一次只出现一次的字符](./SwordToOffer/Doc/第一次只出现一次的字符.md)
 
-- [数组中的逆序对](./SwordToOffer/Doc/数组中的逆序对.md)
-
 - [两个链表的第一个公共节点](./SwordToOffer/Doc/两个链表的第一个公共节点.md)
 
 - [数字在排序数组中出现的次数](./SwordToOffer/Doc/数字在排序数组中出现的次数.md)

SwordToOffer/Doc/二叉树中和为某一数的路径.md

@@ -8,10 +8,55 @@
 
 ## 解题思路
 
+### 思路一
+
 从根节点开始，原来的node.val是int类型的值，现在将其变为从根节点到其的路径（list类型），改变完成之后将该list求和，然后与expectNumber比较，如果相等，判断一下当前节点是否是叶子节点（通过判断其左右子树是否都为None），否则返回False，如果小于expectNumber，则继续往后面遍历，依次类推。
 
 ![image-20190226143959233](https://ws4.sinaimg.cn/large/006tKfTcgy1g0jtj3b5hnj31ho0gm42y.jpg)
 
+### 思路二
+
+采用深度遍历的思想和递归的思想。首先将根结点的值减掉。然后判断是否满足了路径条件，如果不满足就需要对左子树和右子树分别递归。 
+需要注意的是，在每次返回上一层的时候需要通过list.remove()方法返回上一层的状态。
+
+```java
+import java.util.ArrayList;
+/**
+public class TreeNode {
+    int val = 0;
+    TreeNode left = null;
+    TreeNode right = null;
+
+    public TreeNode(int val) {
+        this.val = val;
+    }
+}
+*/
+public class Solution {
+    //因为使用递归，要把实例化放到方法外面，作为成员
+    ArrayList<ArrayList<Integer>> resultList = new ArrayList<ArrayList<Integer>>();
+    ArrayList<Integer> list = new ArrayList<>();
+
+    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
+        //因为数组长度大的放前面，使用深度优先的思想
+        if(root == null){
+            return resultList;
+        }
+        list.add(root.val);
+        target -= root.val;
+        if(target==0 && root.left==null && root.right==null){
+            resultList.add(new ArrayList<Integer>(list));
+            //因为add是添加的引用，如果不new一个出来，在后面对list的操作中会影响到resultList的内容
+        }else{
+            FindPath(root.left, target);
+            FindPath(root.right, target);
+        }
+        list.remove(list.size()-1);
+        return resultList;
+    }
+}
+```
+
 ## 代码
 
 [这里](../Code/23.py)

SwordToOffer/Doc/字符串的排列.md

@@ -9,18 +9,35 @@
 > 输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。
 
 ## 解题思路
-首先，对于求没有重复的n个字符串中所有字符的所有序列，思路是固定第一个，然后求其后面所有n-1个字符串的全排列，然后将第一个字符依次与后面n-1个字符交换位置，这样就能得到所有的排列。
-但是，对于有重复字符的应该如何去重？可以将所有的情况都先遍历出来，然后再去遍历去重，但是这样效率太低，考虑a b b三个字符的情况：
 
-固定a，求得其余两个字符的所有排列情况：bb（一种），然后将a与其交换：
+```
+字典排序算法
+*一个全排列可看做一个字符串，字符串可有前缀、后缀。
+*生成给定全排列的下一个排列.所谓一个的下一个就是这一个与下一个之间没有其他的。这就要求这一个与下一个有尽可能长的共同前缀，也即变化限制在尽可能短的后缀上。
+*[例]839647521是1--9的排列。1—9的排列最前面的是123456789，最后面的987654321，从右向左扫描若都是增的，就到了987654321，也就没有下一个了。否则找出第一次出现下降的位置。
+* 【例】 一般而言，设P是[1,n]的一个全排列。
+*　　　　　　P=P1P2…Pn=P1P2…Pj-1PjPj+1…Pk-1PkPk+1…Pn
+*　　　　find:　　j=max{i|Pi<Pi+1}
+*　　　　　　　　　k=max{i|Pi>Pj}
+*　　　　　　1，  对换Pj，Pk，
+*　　　　　　2，  将Pj+1…Pk-1PjPk+1…Pn翻转
+*          P’= P1P2…Pj-1PkPn…Pk+1PjPk-1…Pj+1即P的下一个  
+*【例】 如何得到346987521的下一个
+*    1，从尾部往前找第一个P(i-1) < P(i)的位置
+*            3 4 6 <- 9 <- 8 <- 7 <- 5 <- 2 <- 1
+*        最终找到6是第一个变小的数字，记录下6的位置i-1
+*    2，从i位置往后找到最后一个大于6的数
+*            3 4 6 -> 9 -> 8 -> 7 5 2 1
+*        最终找到7的位置，记录位置为m
+*    3，交换位置i-1和m的值
+*            3 4 7 9 8 6 5 2 1
+*    4，倒序i位置后的所有数据
+*            3 4 7 1 2 5 6 8 9
+*    则347125689为346987521的下一个排列
+*/
+```
 
-第一个b：bab
-第二个b：bba
 
-- a b b
-- b a b
-
-固定b，求得其余两个字符的所有排列情况：
 
 
 ## 代码

SwordToOffer/Doc/整数中1出现的次数.md

@@ -21,7 +21,7 @@
 比如12212，百位是2，那么从1到12212这些数中百位上出现1的有多少个数？
 应该是：100-199，1100-1199，...，11100-11199，12100-12199，总数是更高位乘以当前位数加一即（12+1）*100=1300个数
 ### 思路二
-遍历所有数，然后数1出现了多少次，四算法复杂度过高，不推荐。
+遍历所有数，然后数1出现了多少次，算法复杂度过高，不推荐。
 
 
 ## 代码

SwordToOffer/Doc/栈的压入&弹出顺序.md

@@ -8,7 +8,7 @@
 例子中的流程：压入1 2 3 4，弹出4，再压入5，再弹栈：5 3 2 1
 
 ## 解题思路
-对照popV，依次便利哦pushV，如果当前待压栈的数与当前可能弹栈的元素相等，则跳过该元素的压栈，否则正常压栈，调到下一个待验证的可能弹栈元素，到最后如果压入栈中的元素个数为0或者压好的栈与剩余的可能弹出栈的元素刚好是相反的则返回True，否则返回False。
+对照popV，依次遍历pushV，如果当前待压栈的数与当前可能弹栈的元素相等，则跳过该元素的压栈，否则正常压栈，调到下一个待验证的可能弹栈元素，到最后如果压入栈中的元素个数为0或者压好的栈与剩余的可能弹出栈的元素刚好是相反的则返回True，否则返回False。
 
 ## 代码
 ```python

SwordToOffer/Doc/树的子结构.md

@@ -7,7 +7,7 @@
 输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
 ## 解题思路
 本来的思路是采用任一一种遍历方式对两棵树同时进行遍历，然后看是否是"子串"关系，但是好像这个思路并行不通。
-正确思路应该是：
+正确思路应该是（直接看代码更清晰）：
 算法1：
 先判断当前两棵树的根节点是否相同，如果相同则直接应用算法2判断pRoot2是否是pRoot1的子树，否则判断pRoot2是否是pRoot1.left的子树，如果是使用算法2，如果不是再判断pRoot2是否是pRoot1.right的子树，如果是使用算法2，如果还不是那就返回False，如果三种情况有一种满足则调用算法2并传入对应的参数。