diff --git a/new_issue/ZConvert.py b/new_issue/ZConvert.py
new file mode 100644
index 00000000..d3012623
--- /dev/null
+++ b/new_issue/ZConvert.py
@@ -0,0 +1,27 @@
+def convert(s, numRows):
+    """
+    :type s: str
+    :type numRows: int
+    :rtype: str
+    """
+    n = len(s)
+    if numRows == 1:
+        return s
+
+    row_num = min(n, numRows)
+    rows = [""] * row_num
+    going_down = False
+    current_row = 0
+    for i in range(n):
+        rows[current_row] += s[i]
+        if current_row == 0 or current_row == row_num - 1:
+            going_down = not going_down
+        current_row += 1 if going_down else -1
+
+    return "".join(rows)
+
+if __name__ == "__main__":
+    s= "PAYPALISHIRING"
+    numRows = 3
+    print convert(s,numRows)
+    
\ No newline at end of file
diff --git a/new_issue/binary-tree-level-order-traversal.py b/new_issue/binary-tree-level-order-traversal.py
new file mode 100644
index 00000000..467ca714
--- /dev/null
+++ b/new_issue/binary-tree-level-order-traversal.py
@@ -0,0 +1,29 @@
+def levelOrder(root):
+    """
+    :type root: TreeNode
+    :rtype: List[List[int]]
+    """
+    if root is None:
+        return []
+    queue = [root]
+    ret = [[]]
+    last_father = root
+    while len(queue) != 0:
+        op_node = queue[0]
+        queue.remove(op_node)
+        if last_father is not None and (last_father.left == op_node or last_father.right == op_node):
+            local_ret = [op_node.val]
+            ret.append(local_ret)
+            last_father = None
+        else:
+            ret[-1].append(op_node.val)
+        if op_node.left is not None:
+            queue.append(op_node.left)
+            if last_father is None:
+                last_father = op_node
+        if op_node.right is not None:
+            queue.append(op_node.right)
+            if last_father is None:
+                last_father = op_node
+
+    return ret
\ No newline at end of file
diff --git a/new_issue/binary-tree-maximum-path-sum.py b/new_issue/binary-tree-maximum-path-sum.py
new file mode 100644
index 00000000..5204afd7
--- /dev/null
+++ b/new_issue/binary-tree-maximum-path-sum.py
@@ -0,0 +1,25 @@
+def maxPathSum(root):
+    """
+    :type root: TreeNode
+    :rtype: int
+    """
+    max_sum = -1001
+
+    def division(node, max_sum):
+        current_max = node.val
+        left_max_sum = -1001
+        right_max_sum = -1001
+        left_max_path = 0
+        right_max_path = 0
+        if node.left is not None:
+            left_max_sum, left_max_path = division(node.left, max_sum)
+
+        if node.right is not None:
+            right_max_sum, right_max_path = division(node.right, max_sum)
+
+        max_path = max(current_max, current_max + left_max_path, current_max + right_max_path)
+        max_sum = max(max_sum, max_path, current_max + left_max_path + right_max_path, left_max_sum, right_max_sum)
+        return max_sum, max_path
+
+    max_sum, max_path = division(root, max_sum)
+    return max(max_sum, max_path)
\ No newline at end of file
diff --git a/new_issue/data_sturct/binary_tree/BFS.py b/new_issue/data_sturct/binary_tree/BFS.py
new file mode 100644
index 00000000..439b378c
--- /dev/null
+++ b/new_issue/data_sturct/binary_tree/BFS.py
@@ -0,0 +1,21 @@
+from initTree import init_tree_from_list
+def bfs(node,op_func):
+    queue = [node]
+
+    while len(queue) != 0:
+        op_node = queue[0]
+        queue.remove(op_node)
+        op_func(op_node)
+        if op_node.left_child is not None:
+            queue.append(op_node.left_child)
+        if op_node.right_child is not None:
+            queue.append(op_node.right_child)
+
+
+if __name__ == "__main__":
+    test_list = range(10)
+    base_node = init_tree_from_list(test_list)
+    def visit(node):
+        print node.value
+
+    bfs(base_node,visit)
\ No newline at end of file
diff --git a/new_issue/data_sturct/binary_tree/DFS.py b/new_issue/data_sturct/binary_tree/DFS.py
new file mode 100644
index 00000000..08dbe30b
--- /dev/null
+++ b/new_issue/data_sturct/binary_tree/DFS.py
@@ -0,0 +1,30 @@
+from initTree import init_tree_from_list
+def dfs_recursion(node,op_func):
+    op_func(node)
+    if node.left_child != None:
+        dfs_recursion(node.left_child,op_func)
+    if node.right_child != None:
+        dfs_recursion(node.right_child,op_func)
+
+def dfs_division(node):
+    ret = [node.value]
+    right = []
+    left = []
+    if node.left_child != None:
+        left = dfs_division(node.left_child)
+
+    if node.right_child != None:
+        right = dfs_division(node.right_child)
+
+    ret += left
+    ret += right
+    return ret
+
+if __name__ == "__main__":
+    test_list = range(10)
+    base_node = init_tree_from_list(test_list)
+    def visit(node):
+        print node.value
+
+    print dfs_division(base_node)
+
diff --git a/new_issue/data_sturct/binary_tree/binaryTree.py b/new_issue/data_sturct/binary_tree/binaryTree.py
new file mode 100644
index 00000000..91dc34ed
--- /dev/null
+++ b/new_issue/data_sturct/binary_tree/binaryTree.py
@@ -0,0 +1,15 @@
+class binaryTreeNode:
+
+    def __init__(self,left_child,right_child,value):
+        self.left_child = left_child
+        self.right_child = right_child
+        self.value = value
+
+    def get_left_child(self):
+        return self.left_child
+
+    def get_right_node(self):
+        return self.right_child
+
+    def get_value(self):
+        return self.value
diff --git a/new_issue/data_sturct/binary_tree/initTree.py b/new_issue/data_sturct/binary_tree/initTree.py
new file mode 100644
index 00000000..17d395fd
--- /dev/null
+++ b/new_issue/data_sturct/binary_tree/initTree.py
@@ -0,0 +1,31 @@
+#coding:utf-8
+from binaryTree import binaryTreeNode
+
+def init_tree_from_list(data_list):
+
+    num = len(data_list)
+    node_list = [0 for _ in range(num)]
+    base_node = binaryTreeNode( None, None,data_list[0])
+    node_list[0] = base_node
+    for i in range(1,num):
+        if data_list[i] == None:
+            continue
+        new_node = binaryTreeNode(None, None, data_list[i])
+        node_list[i] = new_node
+        # 定位父节点
+        if i % 2 == 0:
+            op_node = node_list[i/2 - 1]
+            op_node.right_child = new_node
+        else:
+            op_node = node_list[(i+1)/2 - 1]
+            op_node.left_child = new_node
+
+
+    return base_node
+
+if __name__ == "__main__":
+    test_list = range(3)
+    base_node = init_tree_from_list(test_list)
+    print base_node.value
+    print base_node.left_child.value
+    print base_node.right_child.value
diff --git a/new_issue/data_sturct/binary_tree/inorderTraverse.py b/new_issue/data_sturct/binary_tree/inorderTraverse.py
new file mode 100644
index 00000000..b4b6323a
--- /dev/null
+++ b/new_issue/data_sturct/binary_tree/inorderTraverse.py
@@ -0,0 +1,30 @@
+from initTree import init_tree_from_list
+def inorder_traverse(node,op_func):
+
+    if node.left_child != None:
+        inorder_traverse(node.left_child,op_func)
+
+    op_func(node)
+
+    if node.right_child != None:
+        inorder_traverse(node.right_child,op_func)
+
+
+def inorder_traverse_nonRecursion(node,op_func):
+    stack = []
+    root = node
+    while len(stack) != 0 or root != None:
+        while root != None:
+            stack.append(root)
+            root = root.left_child
+        op_node = stack.pop()
+        op_func(op_node)
+        root = op_node.right_child
+
+
+if __name__ == "__main__":
+    test_list = range(10)
+    root_node = init_tree_from_list(test_list)
+    def visit(node):
+        print node.value
+    inorder_traverse_nonRecursion(root_node,visit)
\ No newline at end of file
diff --git a/new_issue/data_sturct/binary_tree/isBalanced.py b/new_issue/data_sturct/binary_tree/isBalanced.py
new file mode 100644
index 00000000..056459ea
--- /dev/null
+++ b/new_issue/data_sturct/binary_tree/isBalanced.py
@@ -0,0 +1,35 @@
+from initTree import init_tree_from_list
+def isBalanced(root):
+    """
+    :type root: TreeNode
+    :rtype: bool
+    """
+    flag = True
+    if root is None:
+        return flag
+
+    def division(node, depth, flag):
+        if flag is False:
+            return 0, False
+        left_flag = True
+        right_flag = True
+        depth += 1
+        left_depth = depth
+        right_depth = depth
+        if node.left_child is not None:
+            left_depth, left_flag = division(node.left_child, depth, flag)
+        if node.right_child is not None:
+            right_depth, right_flag = division(node.right_child, depth, flag)
+        if abs(right_depth - left_depth) > 1:
+            flag = False
+        else:
+            flag = left_flag and right_flag
+        return max(depth,left_depth, right_depth), flag
+
+    max_depth, flag = division(root, 0, flag)
+    return flag
+
+if __name__ == "__main__":
+    test_list = [1,2,3,4,5,6,None,8]
+    root = init_tree_from_list(test_list)
+    print isBalanced(root)
\ No newline at end of file
diff --git a/new_issue/data_sturct/binary_tree/postorderTraverse.py b/new_issue/data_sturct/binary_tree/postorderTraverse.py
new file mode 100644
index 00000000..48e1dba0
--- /dev/null
+++ b/new_issue/data_sturct/binary_tree/postorderTraverse.py
@@ -0,0 +1,33 @@
+from initTree import init_tree_from_list
+def postorder_traverse(node,op_func):
+    if node.left_child != None:
+        postorder_traverse(node.left_child,op_func)
+
+    if node.right_child != None:
+        postorder_traverse(node.right_child,op_func)
+
+    op_func(node)
+
+def postorder_traverse_nonRecursion(node,op_func):
+    stack = [node]
+    root = node
+    last_node = None
+
+    while len(stack) != 0 or root != None:
+        while root != None:
+            stack.append(root)
+            root = root.left_child
+        op_node = stack[-1]
+        if op_node.right_child == None or op_node.right_child == last_node:
+            op_node = stack.pop()
+            op_func(op_node)
+            last_node = op_node
+        else:
+            root = op_node.right_child
+
+if __name__ == "__main__":
+    test_list = range(10)
+    root_node = init_tree_from_list(test_list)
+    def visit(node):
+        print node.value
+    postorder_traverse_nonRecursion(root_node,visit)
\ No newline at end of file
diff --git a/new_issue/data_sturct/binary_tree/preorderTraverse.py b/new_issue/data_sturct/binary_tree/preorderTraverse.py
new file mode 100644
index 00000000..a8579cab
--- /dev/null
+++ b/new_issue/data_sturct/binary_tree/preorderTraverse.py
@@ -0,0 +1,34 @@
+
+from initTree import init_tree_from_list
+
+def preorder_traverse(node,op_func):
+    op_func(node)
+    if node.left_child != None:
+        preorder_traverse(node.left_child,op_func)
+
+    if node.right_child != None:
+        preorder_traverse(node.right_child,op_func)
+
+
+def preorder_traverse_nonRecursion(node,op_func):
+    stack = [node]
+
+    while len(stack) != 0:
+        op_node = stack.pop()
+        op_func(op_node)
+        if op_node.right_child != None:
+            stack.append(op_node.right_child)
+
+        if op_node.left_child != None:
+            stack.append(op_node.left_child)
+
+
+
+
+if __name__ == "__main__":
+    test_list = range(10)
+    base_node = init_tree_from_list(test_list)
+    def visit(node):
+        print node.value
+
+    preorder_traverse_nonRecursion(base_node,visit)
\ No newline at end of file
diff --git a/new_issue/findMedianSortedArrays.py b/new_issue/findMedianSortedArrays.py
new file mode 100644
index 00000000..42d6750d
--- /dev/null
+++ b/new_issue/findMedianSortedArrays.py
@@ -0,0 +1,17 @@
+
+def findMedianSortedArrays(num1,num2):
+    len1 = len(num1)
+    len2 = len(num2)
+    sum_len = len1+len2
+    all_len = sorted(num1 + num2)
+    if (sum_len)%2 == 0:
+        mid = ((sum_len)/2-1,(sum_len/2))
+        return (float(all_len[mid[0]]) + float(all_len[mid[1]]))/2
+    else:
+        mid = int(sum_len/2)
+        return float(all_len[mid])
+
+if __name__ == "__main__":
+    nums1 = [-1,0,2,3,109]
+    nums2 = [2,73,984]
+    print findMedianSortedArrays(nums1,nums2)
diff --git a/new_issue/lengthOfLongestSubstring.py b/new_issue/lengthOfLongestSubstring.py
new file mode 100644
index 00000000..d3c71042
--- /dev/null
+++ b/new_issue/lengthOfLongestSubstring.py
@@ -0,0 +1,20 @@
+
+def lengthOfLongestSubstring(s):
+    ret_length = 0
+    length = len(s)
+    dupstring = set()
+    rk = -1
+    for i in range(length):
+        if i > 0:
+            dupstring.remove(s[i-1])
+        while rk+1 < length and s[rk+1] not in dupstring:
+            dupstring.add(s[rk+1])
+            rk += 1
+        ret_length = max(ret_length,rk-i+1)
+    return ret_length
+
+if __name__ == "__main__":
+    test_string = "pwwakew"
+    print lengthOfLongestSubstring(test_string)
+
+
diff --git a/new_issue/longestPalindrome.py b/new_issue/longestPalindrome.py
new file mode 100644
index 00000000..d2e17b78
--- /dev/null
+++ b/new_issue/longestPalindrome.py
@@ -0,0 +1,40 @@
+# coding:utf-8
+def longestPalindrome(s):
+    n = len(s)
+    if n < 2:
+        return s
+    max_length = 1
+    ret = s[0]
+
+    # 设定动态规划的状态标识数组
+    dp = [[False]*n for _ in range(n)]
+    # 字符串长度为0时一定为True
+    for i in range(n):
+        dp[i][i] = True
+    # 从2开始，因为i必须小于j
+    for a in range(2,n+1):
+        for i in range(n):
+            j = a + i - 1
+
+            if j >= n:
+                break
+            if s[i] != s[j]:
+                dp[i][j] = False
+            else:
+                # 处理字符串长度为1和2的情况
+                if j - i < 3:
+                    dp[i][j] = True
+                else:
+                    dp[i][j] = dp[i+1][j-1]
+
+            if dp[i][j] and j-i+1 > max_length:
+                ret = s[i:j+1]
+                max_length = j-i+1
+    return ret
+
+
+
+if __name__ == "__main__":
+    #s = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabcaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+    s = "ac"
+    print longestPalindrome(s)
\ No newline at end of file
diff --git a/new_issue/removeDuplicates.py b/new_issue/removeDuplicates.py
new file mode 100644
index 00000000..5a731ca3
--- /dev/null
+++ b/new_issue/removeDuplicates.py
@@ -0,0 +1,21 @@
+class Solution(object):
+    def removeDuplicates(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        if len(nums) == 0:
+            return 0
+
+        slow = 1
+        for index in range(1,len(nums)):
+            if nums[index] != nums[index-1]:
+                nums[slow] = nums[index]
+                slow += 1
+        return slow
+
+if __name__ == "__main__":
+    test_list = [0,0,1,1,1,2,2,3,3,4,4]
+    sol = Solution()
+    new_length = sol.removeDuplicates(test_list)
+    print new_length,test_list[:new_length]
\ No newline at end of file
diff --git a/new_issue/reverse.py b/new_issue/reverse.py
new file mode 100644
index 00000000..5a56bbfe
--- /dev/null
+++ b/new_issue/reverse.py
@@ -0,0 +1,27 @@
+def reverse(x):
+    """
+    :type x: int
+    :rtype: int
+    """
+    if x == 0:
+        return 0
+
+    isNav = x < 0
+    a = str(x)
+    b = a[1:][::-1] if isNav else a[::-1]
+    ret = int(b)
+    top_limit = 2 >> 30
+    if isNav:
+        if ret > top_limit:
+            return 0
+        else:
+            return -ret
+    if ret > top_limit - 1:
+        return 0
+    else:
+        return ret
+
+
+if __name__ == "__main__":
+    x = 13843135
+    print reverse(x)
\ No newline at end of file
diff --git a/new_issue/two_sum.py b/new_issue/two_sum.py
new file mode 100644
index 00000000..0ae4c62c
--- /dev/null
+++ b/new_issue/two_sum.py
@@ -0,0 +1,18 @@
+def twoSum(nums, target):
+    """
+    :type nums: List[int]
+    :type target: int
+    :rtype: List[int]
+    """
+
+    new_dict = {}
+    for i,item in enumerate(nums):
+        if target - item in new_dict:
+            return [i,new_dict[target - item]]
+        new_dict[nums[i]] = i
+
+
+if __name__ == "__main__":
+    nums = [2,7,11,15]
+    target = 9
+    print twoSum(nums,target)
\ No newline at end of file
diff --git a/new_issue/two_sum_listnode.py b/new_issue/two_sum_listnode.py
new file mode 100644
index 00000000..fa21174d
--- /dev/null
+++ b/new_issue/two_sum_listnode.py
@@ -0,0 +1,56 @@
+class ListNode(object):
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+def addTwoNumbers(l1, l2):
+    """
+    :type l1: ListNode
+    :type l2: ListNode
+    :rtype: ListNode
+    """
+    if l1.val == 0 and l1.next is None:
+        return l2
+    if l2.val == 0 and l2.next is None:
+        return l1
+
+    ret = ListNode((l1.val+l2.val)%10)
+    last = ret
+    advance = l1.val+l2.val >= 10
+    l1 = l1.next
+    l2 = l2.next
+    while l1 is not None or l2 is not None:
+        num1 = l1.val if l1 is not None else 0
+        num2 = l2.val if l2 is not None else 0
+        sum = num1 + num2
+        if advance:
+            sum += 1
+        advance = sum >= 10
+        new_node = ListNode(sum%10)
+        last.next = new_node
+        last = new_node
+        l1 = l1.next if l1 is not None else None
+        l2 = l2.next if l2 is not None else None
+    if advance:
+        last.next = ListNode(1)
+    return ret
+
+if __name__ == "__main__":
+    l1 = [0]
+    l2 = [5, 6, 4]
+    test1 = ListNode(l1[0])
+    last1 = test1
+    test2 = ListNode(l2[0])
+    last2 = test2
+    for item in l1[1:]:
+        new_node = ListNode(item)
+        last1.next = new_node
+        last1 = new_node
+    for item in l2[1:]:
+        new_node = ListNode(item)
+        last2.next = new_node
+        last2 = new_node
+    ret = addTwoNumbers(test1,test2)
+    while ret is not None:
+        print ret.val
+        ret = ret.next
\ No newline at end of file