更新

Author: leeguandong

.idea/workspace.xml

@@ -0,0 +1,26 @@
+'''
+题目：输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，
+最长路径的长度为树的深度。
+'''
+
+'''
+思路：利用递归实现。如果一棵树只有一个结点，那么它的深度为1。递归的时候无需判断左右子树是否存在，因为如果该节点
+为叶节点，它的左右子树不存在，那么在下一级递归的时候，直接return 0。同时，记得每次递归返回值的时候，深度加一操
+作，因为计算深度是从根节点下面一个节点开始计算的。
+
+25ms
+5632k
+'''
+
+# -*- coding:utf-8 -*-
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+class Solution:
+    def TreeDepth(self, pRoot):
+        # write code here
+        if pRoot == None:
+            return 0
+        return max(self.TreeDepth(pRoot.left), self.TreeDepth(pRoot.right)) + 1

剑指offer/二叉树的深度.py

@@ -0,0 +1,31 @@
+'''
+题目：输入一个递增排序的数组和一个数字S，在数组中查找两个数，是的他们的和正好是S，如果有多对数字的和等于S，
+输出两个数的乘积最小的
+'''
+
+'''
+思路：设定两个指针，一个指向数组的起点，一个指向数组的终点，然后对两个数字求和，如果和大于目标值，则把后一个指针前移，
+如果和小于目标值，则把前一个指针后移。两个指针交汇的时候如果还没找到，就终止操作。
+
+37ms
+5628k
+'''
+
+# -*- coding:utf-8 -*-
+class Solution:
+    def FindNumbersWithSum(self, array, tsum):
+        # write code here
+        if array == None or len(array) <= 0 or array[-1] + array[-2] < tsum:
+            return []
+        start = 0
+        end = len(array) - 1
+        while start < end:
+            if array[start] + array[end] < tsum:
+                start += 1
+            elif array[start] + array[end] > tsum:
+                end -= 1
+            else:
+                return [array[start], array[end]]
+        return []
+
+

剑指offer/剑指offer-python实现.docx

@@ -0,0 +1,51 @@
+'''
+题目：小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,
+他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,
+21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
+'''
+
+'''
+思路：设定两个指针，先分别指向数字1和数字2，并设这两个指针为small和big，对small和big求和，如果和大于目标值，
+则从当前和中删除small值，并把small值加一，如果和小于目标值，则把big值加一，再把新的big值加入和中。如果和等于
+目标值，就输出small到big的序列，同时把big加一并加入和中，继续之前的操作。
+
+举例看起来更好理解一点，虽然是while循环里面没有做small到big之间的连接加减，但是由于都是从相邻出发，加和都是基于
+1 2 3相邻数基础之上的加和，大了就对第一个数不断减，小了就对最后一个数不断加即可。
+举例：  输入 tsum = 5
+            1    2
+            middle = 3   cursum = 3
+            1 < 3:
+                  3 < 5:
+                       1     2    3
+                       cursum = 1 + 2 + 3 = 6
+                       6 > 5:
+                            cursum - small = 6 - 1 = 5
+                            return       2     3
+
+30ms
+5620k
+'''
+
+# -*- coding:utf-8 -*-
+class Solution:
+    def FindContinuousSequence(self, tsum):
+        # write code here
+        if tsum < 3:
+            return []
+        small = 1
+        big = 2
+        middle = (tsum + 1) // 2
+        cursum = big + small
+        output = []
+
+        while small < middle:
+            if cursum == tsum:
+                output.append(list(range(small, big + 1)))
+            while cursum > tsum and small < middle:
+                cursum -= small
+                small += 1
+                if cursum == tsum:
+                    output.append(list(range(small, big + 1)))
+            big += 1
+            cursum += big
+        return output

剑指offer/和为s的两个数字.py

@@ -0,0 +1,10 @@
+'''
+题目：汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。
+对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后
+的结果，即“XYZdefabc”。是不是很简单？OK，搞定它
+'''
+
+'''
+思路：
+
+'''

剑指offer/和为s的连续整数序列.py

@@ -0,0 +1,37 @@
+'''
+题目：输入一棵二叉树，判断该二叉树是否是平衡二叉树。
+'''
+
+'''
+平衡二叉树：平衡二叉搜索树（Balanced Binary Tree）具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值
+不超过1，并且左右两个子树都是一棵平衡二叉树。
+
+思路：如果二叉树的每个节点的左子树和右子树的深度不大于1，它就是平衡二叉树。
+先写一个求深度的函数，再对每一个节点判断，看该节点的左子树的深度和右子树的深度的差是否大于1
+
+31ms
+5520k
+'''
+
+# -*- coding:utf-8 -*-
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+class Solution:
+    def IsBalanced_Solution(self, pRoot):
+        # write code here
+        if pRoot == None:
+            # 返回True是因为这是最后的判断依据，在不断递归中，最后是叶子节点，即终止，如果叶子节点时，依然左右子树之差小于1，那么就是平衡二叉树，返回True
+            return True
+        depth1 = self.GetDepth(pRoot.left)
+        depth2 = self.GetDepth(pRoot.right)
+        if abs(depth1 - depth2) > 1:
+            return False
+        return self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right)
+
+    def GetDepth(self, root):
+        if not root:
+            return 0
+        return max(self.GetDepth(root.left), self.GetDepth(root.right)) + 1