python实现二叉树几种遍历

二叉树类

首先自定义一个二叉树类，下面所用到的二叉树均基于此二叉树类。

class TreeNode():
    def __init__(self,value=None,left=None,right=None):
        self.val=value
        self.left=left
        self.right=right

定义一个二叉排序树的插入算法，用于生成一个排序树。

def BST_insert(root,value):
    if root == None:
        root= TreeNode(value)
    else:
        if root.val>value:
            root.left= BST_insert(root.left,value)
        else:
            root.right= BST_insert(root.right,value)
    return root

这里先利用前面定义的二叉树类和二叉树插入算法生成一个二叉树。

r=None
input_list=[7,3,9,2,5,8,10,1,4,6]
for v in input_list:
    r=BST_insert(r,v)
res=[]
layer_order(r,res)
print(res)

中序遍历

这里正式开始二叉树的遍历算法，每种次序均包含两种实现方式：递归和迭代。
首先是中序遍历。

# 中序遍历
# 递归法
def mid_order1(root,res_list):
    if not root:
        return
    else:
        mid_order1(root.left,res_list)  # 访问左子树
        res_list.append(root.val)  # 取中间值
        mid_order1(root.right,res_list) # 访问右子树

# 迭代法（使用栈）
def mid_order2(root,res_list):
    temp_stack=[]  # 存储栈
    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

用我们生成的二叉树来测试一下：

mid_order1(r,res)
print(res)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

mid_order2(r,res)
print(res)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

先序遍历

# 先序遍历
# 递归法
def pre_order1(root,res_list):
    if not root:
        return
    res_list.append(root.val)
    pre_order1(root.left,res_list)
    pre_order1(root.right,res_list)

# 迭代法（使用栈）
def pre_order2(root,res_list):
    temp_stack = []  # 存储栈
    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

用我们生成的二叉树来测试一下：

pre_order1(r,res)
print(res)
# [7, 3, 2, 1, 5, 4, 6, 9, 8, 10]

pre_order2(r,res)
print(res)
# [7, 3, 2, 1, 5, 4, 6, 9, 8, 10]

后序遍历

# 后序遍历
# 递归法
def rear_order1(root,res_list):
    if not root:
        return
    rear_order1(root.left, res_list)
    rear_order1(root.right, res_list)
    res_list.append(root.val)
#迭代法
def rear_order2(root,res_list):
    temp_stack = []  # 存储栈
    mid_stack=[]
    while root or temp_stack:
        while root and isinstance(root,TreeNode):
            temp_stack.append(root)
            root=root.left
        if temp_stack:
            root=temp_stack.pop()
        if isinstance(root,TreeNode):
            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

层序遍历

# 自定义队列
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!')

# 层序遍历
def layer_order(root):
    res=[]
    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.append(layer_res)
    return res