add a code directory

Author: cskenken

code/.ipynb_checkpoints/Untitled-checkpoint.ipynb

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

code/1.two-sum.py

@@ -0,0 +1,34 @@
+#
+# [1] Two Sum
+#
+# https://leetcode.com/problems/two-sum
+#
+# Easy (32.90%)
+# Total Accepted:    498409
+# Total Submissions: 1515036
+# Testcase Example:  '[3,2,4]\n6'
+#
+# Given an array of integers, return indices of the two numbers such that they
+# add up to a specific target.
+# 
+# You may assume that each input would have exactly one solution, and you may
+# not use the same element twice.
+# 
+# 
+# Example:
+# 
+# Given nums = [2, 7, 11, 15], target = 9,
+# 
+# Because nums[0] + nums[1] = 2 + 7 = 9,
+# return [0, 1].
+# 
+# 
+#
+class Solution(object):
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        

code/102.binary-tree-level-order-traversal.103096076.ac.py

@@ -0,0 +1,33 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+from collections import deque
+class Solution(object):
+    def levelOrder(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        ll=[]
+        if root==None:
+            return ll
+        q=deque([])
+        q.append(root)
+        
+        while len(q):
+            size=len(q)
+            level_list=[]
+            for i in xrange(size):
+                node=q.popleft()
+                level_list.append(node.val)
+                if node.left:
+                    q.append(node.left)
+                if node.right:
+                    q.append(node.right)
+            ll.append(level_list)
+        return ll
+        
+        

code/104.maximum-depth-of-binary-tree.103080894.ac.py

@@ -0,0 +1,21 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def maxDepth(self,root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        """
+        每次只需要求左右子树高度的最大值，加上1，就是树的高度
+        """
+        if root==None:
+            return 0
+        left_depth=self.maxDepth(root.left)
+        right_depth=self.maxDepth(root.right)
+        return max(left_depth,right_depth) + 1

code/110.balanced-binary-tree.103089976.ac.py

@@ -0,0 +1,59 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    """
+    采用递归方式，每次获得左右子树的深度，判断左右子树是否满足平衡条件
+    使用辅助的函数获得树的深度
+    此种方法中有重复递归
+    """
+    """
+    def isBalanced(self, root):
+        if root==None:
+            return True
+        left_depth=self.maxDepth(root.left)
+        right_depth=self.maxDepth(root.right)
+        diff=left_depth-right_depth
+        if abs(diff)>1:
+            return False
+        return self.isBalanced(root.left) and self.isBalanced(root.right)
+        
+        
+        
+    def maxDepth(self,root):
+        if root==None:
+            return 0
+        return max(self.maxDepth(root.left),self.maxDepth(root.right))+1
+        
+    """
+    
+    """
+    可以将获得深度和判断平衡放在一起，因为都是类似后序遍历,在获得子对象的信息之后再做相应操作
+    """
+    def isBalanced(self,root):
+        
+        return self.solve(root)[1]
+    
+    def solve(self,root):
+        if root==None:
+            return [0,True]
+        tmp1_left=self.solve(root.left)
+        tmp2_right=self.solve(root.right)
+        depth=max(tmp1_left[0],tmp2_right[0])+1
+        
+        if abs(tmp1_left[0]-tmp2_right[0])>1:
+            return [depth,False]
+        else:
+            return [depth,tmp1_left[1] and tmp2_right[1]]
+            
+            
+        
+        
+        
+        
+    
+    

code/111.minimum-depth-of-binary-tree.103083408.ac.py

@@ -0,0 +1,28 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def minDepth(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        """
+        求最小深度和求最大深度相似，但是注意斜树的情况。
+        当左侧子树深度为0时，返回右侧子树的深度+1
+        当右侧子树深度为0时，返回左侧子树的深度+1
+        """
+        if root==None:
+            return 0
+        left_depth=self.minDepth(root.left)
+        right_depth=self.minDepth(root.right)
+        if left_depth==0:
+            return right_depth+1
+        if right_depth==0:
+            return left_depth+1
+        return min(left_depth,right_depth)+1
+