二叉树

#coding=utf8
from collections import deque

class TreeNode:
    def __init__(self,left=None,right=None,data=0):
        self.left = left
        self.right = right
        self.data = data

class Tree:
    def __init__(self,root):
        self.root = root

    def isEmpty(self):
        if root == None:
            return True
        else:
            return False

    def preOrder(self,root):
        if root == None:
            return
        self.preOrder(root.left)
        print root.data
        self.preOrder(root.right)

    def preOrder_non(self,node):
        stack = []
        while stack or node:
            if node:
                stack.append(node)
                node = node.left
            else:
                node = stack.pop()
                print node.data
                node = node.right


    def postOrder(self,root):
        if root == None:
            return
        self.postOrder(root.left)
        self.postOrder(root.right)
        print root.data

    def postOrder_non(self,node):
        queue = []
        stack = []
        queue.append(node)

        while queue:
            node = queue.pop()
            if node:
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                stack.append(node)                
        while stack:
            node = stack.pop()
            print node.data

    def inOrder(self,root):
        if root == None:
            return
        print root.data
        self.inOrder(root.left)
        self.inOrder(root.right)

    def inOrder_non(self,node):
        stack = []
        while stack or node:
            if node:
                print node.data
                stack.append(node)
                node = node.left
            else:
                node = stack.pop()
                node = node.right

    def levelOrder_non(self,node):
        if node == None:
            return
        q = deque([node])
        while q:
            node =  q.popleft()
            print node.data
            if node.left : q.append(node.left)
            if node.right : q.append(node.right)


    def getHeight(self):
        return self.__get_tree_height(self.root)

    def __get_tree_height(self,root):
        if root == None:
            return 0
        if root.left == None and root.right == None:
            return 1

        left_height = self.__get_tree_height(root.left)
        right_height = self.__get_tree_height(root.right)

        if left_height >= right_height:
            height = left_height + 1
        else:
            height = right_height + 1

        return height

    def getleafcount(self):
        return self.__count_leaf_node(self.root)
   
    def __count_leaf_node(self, root):
        if root == None:
            return 0
        if root.left == None and root.right == None:
            return 1
        res_left = self.__count_leaf_node(root.left)
        res_right = self.__count_leaf_node(root.right)
        return res_left + res_right


    def getbranchcount(self):
        return self.__get_branch_node(self.root)
   
    def __get_branch_node(self, root):
        pass

    def replacelem(self):
        self.__replace_element(self.root)
   
    def __replace_element(self, root):
        pass

if __name__ == "__main__":
    node4 = TreeNode(None,None,'4')
    node5 = TreeNode(None,None,'5')
    node6 = TreeNode(None,None,'6')
    node2 = TreeNode(node4,node5,'2')
    node3 = TreeNode(node6,None,'3')
    root = TreeNode(node2,node3,'1')

    tree = Tree(root)
    # tree.preOrder(root)
    # tree.postOrder(root)
    tree.inOrder(root)
    # print "##########"
    # tree.preOrder_non(root)
    # tree.postOrder_non(root)
    # tree.inOrder_non(root)

    # print "@@@@@@@@@@"
    # print tree.getHeight()
    # print tree.getleafcount()