diff --git a/code/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/code/.ipynb_checkpoints/Untitled-checkpoint.ipynb
new file mode 100644
index 00000000..2fd64429
--- /dev/null
+++ b/code/.ipynb_checkpoints/Untitled-checkpoint.ipynb
@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/1.two-sum.py b/code/1.two-sum.py
new file mode 100644
index 00000000..1fdedc7e
--- /dev/null
+++ b/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]
+        """
+        
diff --git a/code/101.symmetric-tree.103350447.ac.py b/code/101.symmetric-tree.103350447.ac.py
new file mode 100644
index 00000000..729e5451
--- /dev/null
+++ b/code/101.symmetric-tree.103350447.ac.py
@@ -0,0 +1,30 @@
+# 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 isSymmetric(self, root):
+        """
+        :type root: TreeNode
+        :rtype: bool
+        """
+        if root==None:
+            return True
+        else:
+            return self.isSymmetricHelper(root.left,root.right)
+        
+        
+            
+    def isSymmetricHelper(self,node1,node2):
+        if node1==None:
+            return node2==None
+        if node2==None:
+            return node1==None
+        if node1.val==node2.val:
+            return self.isSymmetricHelper(node1.left,node2.right) and self.isSymmetricHelper(node1.right,node2.left)
+        return False
+        
+            
\ No newline at end of file
diff --git a/code/102.binary-tree-level-order-traversal.103096076.ac.py b/code/102.binary-tree-level-order-traversal.103096076.ac.py
new file mode 100644
index 00000000..214e84b4
--- /dev/null
+++ b/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
+        
+        
\ No newline at end of file
diff --git a/code/102.binary-tree-level-order-traversal.103309926.ac.py b/code/102.binary-tree-level-order-traversal.103309926.ac.py
new file mode 100644
index 00000000..c51b6217
--- /dev/null
+++ b/code/102.binary-tree-level-order-traversal.103309926.ac.py
@@ -0,0 +1,26 @@
+# 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 levelOrder(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        return self.levelOrderHelper(root,0,[])
+        
+        
+    def levelOrderHelper(self,node,level,ll=[]):
+        if node==None:
+            return []
+        if len(ll)<level+1:
+            ll.append([])
+        ll[level].append(node.val)
+        self.levelOrderHelper(node.left,level+1,ll)
+        self.levelOrderHelper(node.right,level+1,ll)
+        return ll
+        
\ No newline at end of file
diff --git a/code/103.binary-tree-zigzag-level-order-traversal.103312836.ac.py b/code/103.binary-tree-zigzag-level-order-traversal.103312836.ac.py
new file mode 100644
index 00000000..7c77b8bf
--- /dev/null
+++ b/code/103.binary-tree-zigzag-level-order-traversal.103312836.ac.py
@@ -0,0 +1,30 @@
+# 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 zigzagLevelOrder(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        ls=self.zigzagLevelOrderHelper(root,0,[])
+        i=1
+        while i<len(ls):
+            ls[i].reverse()
+            i+=2
+        return ls
+        
+        
+    def zigzagLevelOrderHelper(self,node,level,ll=[]):
+        if node==None:
+            return []
+        if len(ll)<level+1:
+            ll.append([])
+        ll[level].append(node.val)
+        self.zigzagLevelOrderHelper(node.left,level+1,ll)
+        self.zigzagLevelOrderHelper(node.right,level+1,ll)
+        return ll
\ No newline at end of file
diff --git a/code/104.maximum-depth-of-binary-tree.103080894.ac.py b/code/104.maximum-depth-of-binary-tree.103080894.ac.py
new file mode 100644
index 00000000..2091f6dc
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/code/105.construct-binary-tree-from-preorder-and-inorder-traversal.103288428.ac.py b/code/105.construct-binary-tree-from-preorder-and-inorder-traversal.103288428.ac.py
new file mode 100644
index 00000000..b5c84960
--- /dev/null
+++ b/code/105.construct-binary-tree-from-preorder-and-inorder-traversal.103288428.ac.py
@@ -0,0 +1,39 @@
+# 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 buildTree(self, preorder, inorder):
+        """
+        :type preorder: List[int]
+        :type inorder: List[int]
+        :rtype: TreeNode
+        """
+        dict_inorder={}
+        i=0
+        for x in inorder:
+            dict_inorder[x]=i
+            i+=1
+        root=self.buildTreeHelper(preorder,0,len(preorder)-1,inorder,0,len(inorder)-1,dict_inorder)
+        return root
+        
+    
+    def buildTreeHelper(self,preorder,s0,e0,inorder,s1,e1,dict_inorder):
+        if s0>e0 or s1>e1:
+            return None
+        
+        mid=dict_inorder[preorder[s0]]
+        num=mid-s1
+        
+        node=TreeNode(preorder[s0])
+        
+        node.left=self.buildTreeHelper(preorder,s0+1,s0+num,inorder,s1,mid-1,dict_inorder)
+        node.right=self.buildTreeHelper(preorder,s0+num+1,e0,inorder,mid+1,e1,dict_inorder)
+        return node
+        
+        
+        
+        
\ No newline at end of file
diff --git a/code/106.construct-binary-tree-from-inorder-and-postorder-traversal.103286615.ac.py b/code/106.construct-binary-tree-from-inorder-and-postorder-traversal.103286615.ac.py
new file mode 100644
index 00000000..fc963e04
--- /dev/null
+++ b/code/106.construct-binary-tree-from-inorder-and-postorder-traversal.103286615.ac.py
@@ -0,0 +1,41 @@
+# 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 buildTree(self, inorder, postorder):
+        """
+        :type inorder: List[int]
+        :type postorder: List[int]
+        :rtype: TreeNode
+        """
+    
+        dict_inorder={}
+        i=0
+        for x in inorder:
+            dict_inorder[x]=i
+            i+=1
+        root=self.buildTreeHelper(inorder,0,len(inorder)-1,postorder,0,len(postorder)-1,dict_inorder)
+        return root
+        
+    def buildTreeHelper(self,inorder,s0,e0,postorder,s1,e1,dict_inorder):
+        if s0>e0 or s1>e1:
+            return None
+        
+        mid=dict_inorder[postorder[e1]]
+        num=mid-s0
+        
+        node=TreeNode(postorder[e1])
+        
+        node.left=self.buildTreeHelper(inorder,s0,mid-1,postorder,s1,s1+num-1,dict_inorder)
+        node.right=self.buildTreeHelper(inorder,mid+1,e0,postorder,s1+num,e1-1,dict_inorder)
+        
+        return node
+        
+        
+        
+            
+    
\ No newline at end of file
diff --git a/code/107.binary-tree-level-order-traversal-ii.103312143.ac.py b/code/107.binary-tree-level-order-traversal-ii.103312143.ac.py
new file mode 100644
index 00000000..c5d0beaf
--- /dev/null
+++ b/code/107.binary-tree-level-order-traversal-ii.103312143.ac.py
@@ -0,0 +1,30 @@
+# 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 levelOrderBottom(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        ls=self.levelOrderBottomHelper(root,0,[])
+        ls.reverse()
+        return ls
+    
+    
+    def levelOrderBottomHelper(self,node,level,ll=[]):
+        if node==None:
+            return []
+        if len(ll)<level+1:
+            ll.append([])
+        ll[level].append(node.val)
+        self.levelOrderBottomHelper(node.left,level+1,ll)
+        self.levelOrderBottomHelper(node.right,level+1,ll)
+        return ll
+        
+        
+        
\ No newline at end of file
diff --git a/code/110.balanced-binary-tree.103089976.ac.py b/code/110.balanced-binary-tree.103089976.ac.py
new file mode 100644
index 00000000..4a2e7c13
--- /dev/null
+++ b/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]]
+            
+            
+        
+        
+        
+        
+    
+    
\ No newline at end of file
diff --git a/code/111.minimum-depth-of-binary-tree.103083408.ac.py b/code/111.minimum-depth-of-binary-tree.103083408.ac.py
new file mode 100644
index 00000000..4b202e35
--- /dev/null
+++ b/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
+        
\ No newline at end of file
diff --git a/code/111.minimum-depth-of-binary-tree.103313518.ac.py b/code/111.minimum-depth-of-binary-tree.103313518.ac.py
new file mode 100644
index 00000000..cf6a7c2f
--- /dev/null
+++ b/code/111.minimum-depth-of-binary-tree.103313518.ac.py
@@ -0,0 +1,22 @@
+# 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
+        """
+        if root==None:
+            return 0
+        if root.left==None:
+            return self.minDepth(root.right)+1
+        if root.right==None:
+            return self.minDepth(root.left)+1
+        return min(self.minDepth(root.right),self.minDepth(root.left))+1
+        
+            
\ No newline at end of file