基于Python实现二叉树相关方法实现(手记)

from queue import Queue

class Node:
#二叉树初始化
    def __init__(self, data):
        self.left = None  # 左节点
        self.right = None  # 右节点
        self.data = data  # 值

#判断是否为空树
    def isEmptyTree(self,root):
        if not root: return True
        else: return False

#向二叉树插入一个元素
    def insert(self,value):
        if self.data:
            if value<self.data:
                if self.left is None:
                    self.left=Node(value)
                else:
                    self.left.insert(value)
            elif value>self.data:
                if self.right is None:
                    self.right=Node(value)
                else:
                    self.right.insert(value)
        else:
            self.data=value
#先序遍历
    def PreorderTraversal(self, root):
        res = []
        if root:
            res.append(root.data)
            res = res+self.PreorderTraversal(root.left)
            res = res + self.PreorderTraversal(root.right)
        return res

#中序遍历
    def inorderTraversal(self,root):
        res=[]
        if root:
            res=self.inorderTraversal(root.left)
            res.append(root.data)
            res=res+self.inorderTraversal(root.right)
        return res

#后序遍历
    def PostorderTraversal(self, root):
        res = []
        if root:
            res = self.PostorderTraversal(root.left)
            res = res + self.PostorderTraversal(root.right)
            res.append(root.data)
        return res

#层次遍历
    def levelorder_traversal(self,root):
        list=[]
        queue=Queue()
        queue.put(root)
        while not queue.empty():
            root=queue.get()
            list.append(root.data)
            if root.left:
                queue.put(root.left)
            if root.right:
                queue.put(root.right)
        return list

#获得二叉树高度
    def getTreeHeight(self,root):
        if not root:
            return 0
        else:
            leftheight=1+self.getTreeHeight(root.left)
            rightheight=1+self.getTreeHeight(root.right)
        return max(leftheight,rightheight)

#获取叶子结点个数
    def getLeafSum(self,root):
        if not root:
            return 0
        elif root.left==None and root.right==None:
            return 1
        else:
            return self.getLeafSum(root.left)+self.getLeafSum(root.right)

# 获取整个树结点个数
    def totalTreeSum(self,root):
        if not root:
            return 0
        else:
            return 1+self.totalTreeSum(root.left)+self.totalTreeSum(root.right)

# 获得第n层节点数
    def getNodeNum(self,root,num):
        if num==1:
            if not root:
                return 0
            else:return 1
        else:
            return self.getNodeNum(root.left,num-1)+self.getNodeNum(root.right,num-1)

# 返回某个双亲结点的值
    def getParent(self,root,value):
        if not root: return None
        if (root.left is not None and root.left.data==value )or (root.right is not None
                and root.right.data==value):
            return root.data

        p = self.getParent(root.left, value)
        if p is not None: return p
        else: return self.getParent(root.right,value)

#返回某个节点的左孩子或右孩子结点
    def getLeft(self,root):
        if not root:return None
        else: return root.left

    def getRight(self,root):
        if not root:return None
        else: return root.right

#查找二叉树中某一个元素
    def findNode(self,root,value):
        if not root:return None
        if root.data==value: return root
        p=self.findNode(self.getLeft(root), value)
        if p is not None: return p
        else:
            t = self.findNode(self.getRight(root), value)
            if t is not None: return t
            else:return p

#先序非递归遍历
    def pre_travel(self,root):
        stack=[]
        res=[]
        while stack!=[] or root:
            while root:
                stack.append(root)
                res.append(root.data)
                root=root.left
            if stack!=[]:
                root=stack.pop()
                root=root.right
        return res

#中序非递归遍历
    def in_travel(self, root):
        stack = []
        res=[]
        while root or stack:
            while root:
                stack.append(root)
                root=root.left
            root=stack.pop()
            res.append(root.data)
            root=root.right
        return res

#后序非递归遍历
    def post_travel(self,root):
        if not root:
            return
        stack1=[]
        stack2=[]
        res = []
        stack1.append(root)
        while stack1:
            node=stack1.pop()
            if node.left:
                stack1.append(node.left)
            if node.right:
                stack1.append(node.right)
            stack2.append(node)
        while stack2:
            res.append(stack2.pop().data)
        return res

# @profile
#销毁二叉树
def destroy_tree(root):
    if root==Node:
        return
    if root.left:
        destroy_tree(root.left)
    if root.right:
        destroy_tree(root.right)
    root=None
    print("已销毁")

if __name__ == "__main__":

    root = Node(12)
    root.insert(6)
    root.insert(14)
    root.insert(3)
    root.insert(8)

    print("是否为空二叉树:%s"%root.isEmptyTree(root))

    print("先序遍历:%s"%root.PreorderTraversal(root))
    print("中序遍历:%s"%root.inorderTraversal(root))
    print("后序遍历:%s"%root.PostorderTraversal(root))

    print("层次遍历:%s" % root.levelorder_traversal(root))

    print("先序非递归遍历:%s" % root.pre_travel(root))
    print("中序非递归遍历:%s" % root.in_travel(root))
    print("后序非递归遍历:%s" % root.post_travel(root))

    print("二叉树高度:%d"%root.getTreeHeight(root))
    print("二叉树叶子结点总数:%d"%root.getLeafSum(root))
    print("二叉树第二层结点数:%d"%root.getNodeNum(root,2))
    print("二叉树结点总数:%d"%root.totalTreeSum(root))

    print("结点所含元素8的父节点值:%d"%root.getParent(root,8))
    print("父节点的左节点的左节点的元素值:%d"%root.getLeft(root.left).data)
    print("含元素6的节点的左节点的元素值:%d"%root.getLeft(root.findNode(root,6)).data)
    destroy_tree(root)

运行结果