2.25

Author: DmrfCoder

README.md

@@ -17,7 +17,12 @@
 - [合并两个排序的链表](./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/Code/18.py

@@ -9,20 +9,21 @@ class Solution:
     def printMatrix(self, matrix):
         # write code here
         size = len(matrix)
-        size = int(np.sqrt(size))
-        matrix = np.reshape(np.array(matrix), newshape=(size, size))
 
         newArray = []
+        if size==1:
+            newArray.append(matrix[0][0])
+            return newArray
 
-        for index1 in range(0, int(size / 2)):
+        for index1 in range(0, size):
             for index2 in range(index1, size - index1 - 1):
-                newArray.append(matrix[index1, index2])
+                newArray.append(matrix[index1][ index2])
             for index3 in range(index1, size - index1 - 1):
-                newArray.append(matrix[index3, size - index1 - 1])
+                newArray.append(matrix[index3][ size - index1 - 1])
             for index4 in range(size - index1 - 1, index1, -1):
-                newArray.append(matrix[size - index1 - 1, index4])
+                newArray.append(matrix[size - index1 - 1][ index4])
             for index5 in range(size - index1 - 1, index1, -1):
-                newArray.append(matrix[index5, index1])
+                newArray.append(matrix[index5][ index1])
 
         return newArray
 
@@ -32,15 +33,14 @@ def reversematrix(self,matrix):
         for i in range(s[1]-1,-1,-1):
             a=[]
             for j in range(s[0]):
-                a.append(matrix[j,i])
+                a.append(matrix[j][i])
             newmatrix.append(a)
         newmatrix=np.array(newmatrix)
         return newmatrix
 
     def printMatrix2(self, matrix):
         newArray=[]
         matrix=np.array(matrix)
-        print matrix
         while len(matrix)!=0:
             newArray.extend(matrix[0])
             matrix=matrix[1:]
@@ -49,4 +49,5 @@ def printMatrix2(self, matrix):
 
 
 s = Solution()
-s.printMatrix2([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
+#print s.printMatrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
+print s.printMatrix([[1]])

SwordToOffer/Code/19.py

@@ -0,0 +1,48 @@
+# -*- coding:utf-8 -*-
+class Solution:
+    def __init__(self):
+        self.a = []
+        self.b = []
+        self.count = 0
+
+    def push(self, node):
+        # write code here
+        if self.count == 0:
+            self.b.append(node)
+            self.count += 1
+
+        elif node < self.b[-1]:
+            self.b.append(node)
+            self.count += 1
+        else:
+            self.b.append(self.b[-1])
+            self.count += 1
+        self.a.append(node)
+
+    def pop(self):
+        # write code here
+        r = self.a[-1]
+        self.a.pop()
+        self.b.pop()
+        self.count -= 1
+        return r
+
+    def top(self):
+        # write code here
+        return self.a[-1]
+
+    def min(self):
+        # write code here
+        return self.b[-1]
+
+
+a = ["PSH3", "MIN", "PSH4", "MIN", "PSH2", "MIN", "PSH3", "MIN", "POP", "MIN", "POP", "MIN", "POP", "MIN", "PSH0",
+     "MIN"]
+
+s = Solution()
+for item_a in a:
+    s.push(item_a)
+
+for i in range(len(a)):
+    print s.min()
+    s.pop()

SwordToOffer/Code/20.py

@@ -0,0 +1,51 @@
+# -*- coding:utf-8 -*-
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+
+class Solution:
+    def __init__(self):
+        self.s=[]
+
+    # 返回从上到下每个节点值列表，例：[1,2,3]
+    def PrintFromTopToBottom(self, root):
+        # write code here
+        a = []
+        if root is None:
+            return a
+
+        self.s.append(root)
+        a.append(root.val)
+        while self.s:
+            t=self.s[0]
+            del self.s[0]
+            if t.left is not None:
+                self.s.append(t.left)
+                a.append(t.left.val)
+            if t.right is not None:
+                self.s.append(t.right)
+                a.append(t.right.val)
+
+        return a
+
+
+
+pRoot8 = TreeNode(8)
+treeNode6 = TreeNode(6)
+treeNode10 = TreeNode(10)
+treeNode5 = TreeNode(5)
+treeNode7 = TreeNode(7)
+treeNode9 = TreeNode(9)
+treeNode11 = TreeNode(11)
+
+pRoot8.left = treeNode6
+pRoot8.right = treeNode10
+treeNode6.left = treeNode5
+treeNode6.right = treeNode7
+treeNode10.left = treeNode9
+treeNode10.right = treeNode11
+
+s=Solution()
+print s.PrintFromTopToBottom(pRoot8)

SwordToOffer/Code/21.py

@@ -0,0 +1,17 @@
+# -*- coding:utf-8 -*-
+class Solution:
+    def __init__(self):
+        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
+                else:
+
+
+

SwordToOffer/Code/22.py

@@ -0,0 +1,15 @@
+# 二叉搜索树的后序遍历
+
+<center>知识点：</center>
+
+
+## 题目描述
+输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
+## 解题思路
+首先要明确什么是二叉搜索树：
+它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。
+
+
+## 代码
+
+[这里](../Code/n.py)

SwordToOffer/Doc/二叉搜索树的后序遍历.md

@@ -0,0 +1,14 @@
+# 从上往下打印二叉树
+
+<center>知识点：二叉树</center>
+
+
+## 题目描述
+从上往下打印出二叉树的每个节点，同层节点从左至右打印。
+## 解题思路
+利用队列的思想，刚开始将根节点入队（如果根节点不为空），然后开始循环，每个循环从队列中取出第一个作为当前元素，对每一个元素，先将其遍历，然后将其左节点、右节点顺序入队（如果不为空），以此类推。
+
+
+## 代码
+
+[这里](../Code/21.py)

SwordToOffer/Doc/从上往下打印二叉树.md

@@ -0,0 +1,56 @@
+# 包含min函数的栈
+
+<center>知识点：栈</center>
+
+
+## 题目描述
+定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
+## 解题思路
+使用两个数组，第一个数组用来实现栈先入后出的功能（记为数组A），第二个栈实现存储当前栈最小值的功能（记为数组B），具体做法是，每来
+一个待入栈的元素，将其先入数组A，然后将其与数组B的最后一个元素即B栈的栈顶比较，如果当前元素比B栈栈顶小，则将其入B栈，否则将B栈的倒数第一个再入一次栈，弹栈时A和B同时弹，这样可以保证B栈的当前栈顶一定是A栈中的最小元素，而且避免了弹栈时A和B栈元素个数不一样的情况。
+举个例子：元素为[7,3,4,8,7,1,10],那么A个B栈的元素应该是：
+A：[7,3,4,8,7,1,10]
+B：[7,3,3,3,3,1,1]
+这样弹栈顺序和对应时刻min值为：
+弹栈：10，1，7，8，4，3，7
+min：1，1，3，3，3，3，7
+## 代码
+```python
+class Solution:
+    def __init__(self):
+        self.a = []
+        self.b = []
+        self.count = 0
+
+    def push(self, node):
+        # write code here
+        if self.count == 0:
+            self.b.append(node)
+            self.count += 1
+
+        elif node < self.b[-1]:
+            self.b.append(node)
+            self.count += 1
+        else:
+            self.b.append(self.b[-1])
+            self.count += 1
+        self.a.append(node)
+
+    def pop(self):
+        # write code here
+        r = self.a[-1]
+        self.a.pop()
+        self.b.pop()
+        self.count -= 1
+        return r
+
+    def top(self):
+        # write code here
+        return self.a[-1]
+
+    def min(self):
+        # write code here
+        return self.b[-1]
+
+```
+[这里](../Code/19.py)

SwordToOffer/Doc/包含min函数的栈.md

@@ -0,0 +1,14 @@
+# 栈的压入&弹出顺序
+
+<center>知识点：栈</center>
+
+
+## 题目描述
+输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
+## 解题思路
+
+
+
+## 代码
+
+[这里](../Code/20.py)