2.26

DmrfCoder · DmrfCoder · commit cd4410e784b2 · 2019-02-26T16:50:25.000+08:00
diff --git a/README.md b/README.md
@@ -1,28 +1,58 @@
 # 牛客网-剑指offer
 
 - [二维数组中的查找](./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)
+
 - [二进制中1的个数](./SwordToOffer/Doc/二进制中1的个数.md)
+
 - [***数值的整数次方***](./SwordToOffer/Doc/数值的整数次方.md)
+
 - [调整数组顺序使奇数位于偶数前面](./SwordToOffer/Doc/调整数组顺序使奇数位于偶数前面.md)
+
 - [链表中倒数第k个节点](./SwordToOffer/Doc/链表中倒数第k个节点.md)
+
 - [反转链表](./SwordToOffer/Doc/反转链表.md)
+
 - [合并两个排序的链表](./SwordToOffer/Doc/合并两个排序的链表.md)
+
 - [***树的子结构***](./SwordToOffer/Doc/树的子结构.md)
+
 - [***树的镜像***](./SwordToOffer/Doc/树的镜像.md)
+
 - [***顺时针打印矩阵***](./SwordToOffer/Doc/顺时针打印矩阵.md)
+
 - [***包含min函数的栈***](./SwordToOffer/Doc/包含min函数的栈.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)
+
+  
 
 
 
diff --git a/SwordToOffer/Code/20.py b/SwordToOffer/Code/20.py
@@ -0,0 +1,35 @@
+# -*- coding:utf-8 -*-
+class Solution:
+    def IsPopOrder(self, pushV, popV):
+        # write code here
+        size = len(pushV)
+        popIndex = 0
+        a = []
+        for i in range(size):
+            if pushV[i] == popV[popIndex]:
+                popIndex += 1
+            else:
+                a.append(pushV[i])
+
+        if len(a)==0:
+            return True
+
+        if popIndex >= size:
+            return False
+        else:
+            size2 = len(a)
+            if size2 != size - popIndex:
+                return False
+            else:
+                flag = True
+                for i in range(size2):
+                    if a[i] != popV[- (i+1)]:
+                        flag = False
+                        break
+                    else:
+                        popIndex += 1
+                return flag
+
+
+s = Solution()
+print s.IsPopOrder([1], [1])
diff --git a/SwordToOffer/Code/22.py b/SwordToOffer/Code/22.py
@@ -1,17 +1,41 @@
 # -*- coding:utf-8 -*-
 class Solution:
     def __init__(self):
-        self.stk=[]
+        self.stk = []
 
     def VerifySquenceOfBST(self, sequence):
         # write code here
-        a=[]
-        flag=0
-        for i in range(len(sequence)):
-            if sequence[i]<sequence[i+1] :
-                if flag==0:
-                    flag=1
+
+        size = len(sequence)
+        if sequence is None:
+            return True
+        if size==0:
+            return False
+        rootNode = sequence[-1]
+        smallS = []
+        bigS = []
+        flag = True
+        for i in range(size - 1):
+            if sequence[i] < rootNode:
+                if flag:
+                    smallS.append(sequence[i])
                 else:
+                    return False
+            elif sequence[i] > rootNode:
+                if flag:
+                    flag = False
+                bigS.append(sequence[i])
+            else:
+                return False
+        flagS=True
+        if len(smallS)>0:
+            flagS=self.VerifySquenceOfBST(smallS)
+        flagB=True
+        if len(bigS)>0:
+            flagB=self.VerifySquenceOfBST(bigS)
 
 
+        return flagS and flagB
 
+s=Solution()
+print s.VerifySquenceOfBST([1,2,3,4,5])
diff --git a/SwordToOffer/Code/23.py b/SwordToOffer/Code/23.py
@@ -0,0 +1,91 @@
+# -*- coding:utf-8 -*-
+import copy
+
+
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+
+
+def cmp(a, b):
+    if len(a) > len(b):
+        return -1
+    else:
+        return 0
+
+
+class Solution:
+
+    # 返回二维列表，内部每个列表表示找到的路径
+    def FindPath(self, root, expectNumber):
+        # write code here
+        if root == None:
+            return []
+
+        if root.val==expectNumber:
+            return [[1]]
+        if root.val>expectNumber:
+            return []
+
+        result = []
+        a = []
+        root.val = [root.val]
+        a.append(root)
+
+
+
+
+        while a:
+            cnode = a[0]
+            del a[0]
+
+
+            if cnode.left != None:
+                c = sum(cnode.val) + cnode.left.val
+                if c < expectNumber:
+                    temp = copy.copy(cnode.left.val)
+                    cnode.left.val = copy.copy(cnode.val)
+                    cnode.left.val.append(temp)
+                    a.append(cnode.left)
+                elif c > expectNumber:
+                    cnode.left = None
+                elif cnode.left.left == None and cnode.left.right == None:
+                    t = copy.copy(cnode.val)
+                    t.append(cnode.left.val)
+                    result.append(t)
+
+            if cnode.right != None:
+                c = sum(cnode.val)+ cnode.right.val
+                if c < expectNumber:
+                    temp = copy.copy(cnode.right.val)
+                    cnode.right.val = copy.copy(cnode.val)
+                    cnode.right.val.append(temp)
+
+                    a.append(cnode.right)
+                elif c > expectNumber:
+                    cnode.right = None
+                elif cnode.right.left == None and cnode.right.right == None:
+                    t = copy.copy(cnode.val)
+                    t.append(cnode.right.val)
+                    result.append(t)
+
+        result=sorted(result,cmp )
+        return result
+
+
+pRoot8 = TreeNode(10)
+treeNode1 = TreeNode(5)
+treeNode2 = TreeNode(12)
+treeNode3 = TreeNode(4)
+treeNode4 = TreeNode(7)
+treeNode5 = TreeNode(3)
+treeNode6 = TreeNode(10)
+
+# pRoot8.left = treeNode1
+# pRoot8.right = treeNode2
+# treeNode1.left = treeNode3
+# treeNode1.right = treeNode4
+s = Solution()
+print s.FindPath(pRoot8, 10)
diff --git a/SwordToOffer/Code/24.py b/SwordToOffer/Code/24.py
@@ -0,0 +1,63 @@
+# -*- coding:utf-8 -*-
+class RandomListNode:
+    def __init__(self, x):
+        self.label = x
+        self.next = None
+        self.random = None
+
+
+class Solution:
+    # 返回 RandomListNode
+    def Clone(self, pHead):
+        # write code here
+        currentNode = pHead
+        if pHead is None:
+            return None
+
+        while currentNode is not None:
+            node = RandomListNode(currentNode.label)
+            node.next = currentNode.next
+            currentNode.next = node
+            currentNode = currentNode.next.next
+
+        currentNode = pHead
+        while currentNode is not None:
+            node = currentNode.next
+            if currentNode.random is not None:
+                node.random = currentNode.random.next
+            currentNode = node.next
+
+        currentNode = pHead
+        cloneP = pHead.next
+
+        while currentNode.next is not None:
+            temp = currentNode.next
+            currentNode.next = temp.next
+            currentNode = temp
+        return cloneP
+
+
+head = RandomListNode(1)
+node2 = RandomListNode(2)
+node3 = RandomListNode(3)
+node4 = RandomListNode(4)
+node5 = RandomListNode(5)
+nodex = RandomListNode('#')
+
+head.next = node2
+head.random = node3
+
+node2.next = node3
+node2.random = node5
+
+node3.next = node4
+node3.random = nodex
+
+node4.next = node5
+node4.random = node2
+
+node5.random = nodex
+
+s = Solution()
+h = s.Clone(head)
+a = 0
diff --git a/SwordToOffer/Code/25.py b/SwordToOffer/Code/25.py
@@ -0,0 +1,10 @@
+# -*- coding:utf-8 -*-
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+class Solution:
+    def Convert(self, pRootOfTree):
+        # write code here
+        pass
diff --git a/SwordToOffer/Code/26.py b/SwordToOffer/Code/26.py
@@ -0,0 +1,12 @@
+# -*- coding:utf-8 -*-
+class Solution:
+    def Permutation(self, ss):
+        # write code here
+        if len(ss)==1:
+            return ss
+
+        t = self.Permutation(ss[1:])
+
+
+s = Solution()
+s.Permutation('abcd')
diff --git a/SwordToOffer/Doc/二叉搜索树与双向链表.md b/SwordToOffer/Doc/二叉搜索树与双向链表.md
@@ -0,0 +1,14 @@
+# 二叉搜索树与双向链表
+
+<center>知识点：</center>
+
+
+## 题目描述
+输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
+## 解题思路
+
+
+
+## 代码
+
+[这里](../Code/25.py)
diff --git a/SwordToOffer/Doc/二叉搜索树的后序遍历.md b/SwordToOffer/Doc/二叉搜索树的后序遍历.md
@@ -9,6 +9,11 @@
 首先要明确什么是二叉搜索树：
 它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。
 
+二叉搜索树的后序遍历一定满足以下条件：
+- 最后一个元素是根节点
+- 从第一个到第倒数第一个一定可以分为两部分，前一部分都比根节点小，后一部分都比根节点大，且这两部分都是二叉搜索树
+
+根据以上两个特点使用递归即可解决。
 
 ## 代码
 
diff --git a/SwordToOffer/Doc/二叉树中和为某一数的路径.md b/SwordToOffer/Doc/二叉树中和为某一数的路径.md
@@ -0,0 +1,17 @@
+# 二叉树中和为某一数的路径
+
+<center>知识点：</center>
+
+
+## 题目描述
+输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)
+
+## 解题思路
+
+从根节点开始，原来的node.val是int类型的值，现在将其变为从根节点到其的路径（list类型），改变完成之后将该list求和，然后与expectNumber比较，如果相等，判断一下当前节点是否是叶子节点（通过判断其左右子树是否都为None），否则返回False，如果小于expectNumber，则继续往后面遍历，依次类推。
+
+![image-20190226143959233](https://ws4.sinaimg.cn/large/006tKfTcgy1g0jtj3b5hnj31ho0gm42y.jpg)
+
+## 代码
+
+[这里](../Code/23.py)
diff --git a/SwordToOffer/Doc/复杂链表的复制.md b/SwordToOffer/Doc/复杂链表的复制.md
diff --git a/SwordToOffer/Doc/字符串的排列.md b/SwordToOffer/Doc/字符串的排列.md
diff --git a/SwordToOffer/Doc/栈的压入&弹出顺序.md b/SwordToOffer/Doc/栈的压入&弹出顺序.md
