二叉树 两道题 104 110

Author: wb.xubilin

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)

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)
+

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)

new_issue/data_sturct/binary_tree/preorderTraverse.py

@@ -1,4 +1,4 @@
-from binaryTree import binaryTreeNode
+
 from initTree import init_tree_from_list
 
 def preorder_traverse(node,op_func):