自定义二叉树（python）及相关算法

# 自定义队列
class Node():
    def __init__(self,data,next=None):
        self.data = data
        self.next=next
class myque():
    def __init__(self):
        self.length=0
        self.left=None
        self.right=None
    def is_empty(self):
        return self.left==None  # 根据左侧节点判断队列是否为空
    def enque(self,value):
        self.length+=1
        nd = Node(value)
        if not self.left:
            self.left=nd
            self.right=nd
        else:
            self.right.next=nd
            self.right=nd
    def deque(self):
        if self.left:  # 根据左侧节点判断队列是否为空
            r = self.left
            self.left=self.left.next
            self.length-=1
            return r.data
        else:
            raise ValueError('empty queue!')
class BinaryTree:
    def __init__(self,value=None,left=None,right=None):
        self.val = value
        self.left = left
        self.right = right
    @classmethod  # 计算二叉树的高度（递归方式）
    def depth(cls,root):
        if root == None:
            return 0
        else:
            return max(cls.depth(root.left),cls.depth(root.right)) +1

    @classmethod  # 插入元素（非递归方式）
    def insert(cls,root,value=None):
        if root == None:
            return BinaryTree(value)
        ori_root = root
        while root != None:
            if root.val > value:
                if root.left != None:
                    root = root.left
                else:
                    root.left = BinaryTree(value)
                    break
            elif root.val < value:
                if root.right != None:
                    root = root.right
                else:
                    root.right = BinaryTree(value)
                    break
            else:  # 二叉树中已存在则不插入
                break
        return ori_root

    @classmethod  # 中序遍历（非递归方式）借助栈
    def mid_order(cls,root):
        temp_stack = []  # 存储栈
        res_list=[]
        while root or temp_stack:
            while root:
                temp_stack.append(root)
                root = root.left
            root = temp_stack.pop()
            res_list.append(root.val)
            root = root.right
        return res_list

    @classmethod  # 先序遍历（非递归方式）借助栈
    def pre_order(cls,root):
        temp_stack = []  # 存储栈
        res_list = []
        while root or temp_stack:
            while root:
                res_list.append(root.val)
                temp_stack.append(root)
                root = root.left
            root = temp_stack.pop()
            root = root.right
        return res_list

    @classmethod  # 后序遍历（非递归方式）借助栈
    def rear_order(cls,root):
        res_list=[] # 存储结果
        temp_stack = []  # 存储当前的root
        while root or temp_stack:  # root或栈不为空
            while root and isinstance(root, BinaryTree): # root是树
                temp_stack.append(root)
                root = root.left
            if temp_stack:
                root = temp_stack.pop()
            if isinstance(root, BinaryTree):
                if not root.right:
                    res_list.append(root.val)
                    root = root.right
                else:
                    temp_stack.append(root.val)
                    root = root.right
            else:
                res_list.append(root)
                if not temp_stack:
                    break
        return res_list

    @classmethod  # 层序遍历（非递归方式），借助队列
    def layer_order(cls,root):
        res_list = []
        temp_queue = myque()
        temp_queue.enque(root)
        while not temp_queue.is_empty():
            layer_res = []
            for i in range(temp_queue.length):
                curr = temp_queue.deque()
                layer_res.append(curr.val)
                if curr.left:
                    temp_queue.enque(curr.left)
                if curr.right:
                    temp_queue.enque(curr.right)
            res_list.append(layer_res)
        return res_list


if __name__=='__main__':
    root = None
    test_list = [7, 3, 9, 2, 4, 8, 10]
    for v in test_list:
        root = BinaryTree.insert(root, v)

    print(BinaryTree.depth(root))
    res_mid = BinaryTree.mid_order(root)
    res_pre = BinaryTree.pre_order(root)
    res_rear = BinaryTree.rear_order(root)
    res_layer = BinaryTree.layer_order(root)
    print(res_mid)
    print(res_pre)
    print(res_rear)
    print(res_layer)