二叉树的构造和七种遍历算法

原创于 2019-10-29 02:02:50 发布 · 262 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了二叉树的基本概念，包括二叉树的节点结构，并详细讲解了如何构造二叉树。接着，文章深入探讨了层次遍历以及前序、中序、后序三种遍历方式的递归和非递归实现。无论是对于初学者还是进阶者，都是理解二叉树遍历的宝贵资料。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

二叉树的节点类：

class Node(object):
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

构造一棵二叉树：

class Build_Tree(object):
    def __init__(self):
        self.root = None
        self.queue = []
    def add(self, data):
        node = Node(data)
        if not self.root:
            self.root = node
        else:
            temp = self.queue[0]
            if not temp.left:
                temp.left = node
            elif not temp.right:
                temp.right = node
                self.queue.pop(0)
        self.queue.append(node)

l = [1,2,3,4,5,6,7,8,9]
tree = Build_Tree()
for i in l:
    tree.add(i)
root = tree.root

层次遍历：

import sys

if sys.version > '3':     # python 2 3 queue 不兼容
    from queue import Queue
else:
    from Queue import Queue

def level_order(root):
    q = Queue()
    if root:
        q.put(root)
    while not q.empty():
        temp = q.get()
        if temp.left:
            q.put(temp.left)
        if temp.right:
            q.put(temp.right)
        level_res.append(temp.data)

level_res = []
level_order(root)
print 'level_res:', level_res

前序、中序、后序遍历的递归方法：

def pre_order(root):
    if root:
        pre_res.append(root.data)
        pre_order(root.left)
        pre_order(root.right)

def mid_order(root):
    if root:
        mid_order(root.left)
        mid_res.append(root.data)
        mid_order(root.right)

def post_order(root):
    if root:
        post_order(root.left)
        post_order(root.right)
        post_res.append(root.data)

pre_res = []
pre_order(root)
print 'pre_res:', pre_res

mid_res = []
mid_order(root)
print 'mid_res:', mid_res

post_res = []
post_order(root)
print 'post_res:', post_res

前序遍历的非递归形式：

def pre_order_without_recursion(root):
    s = []
    while root or s:
        if root:
            pre_res_without_rec.append(root.data)
            s.append(root.right)
            root = root.left
            #s.append(root.right)
        else:
            root = s.pop()

pre_res_without_rec = []
pre_order_without_recursion(root)
print 'pre_res_without_rec:', pre_res_without_rec

中序遍历的非递归形式：

def mid_order_without_recursion(root):
    s = []
    while root or s:
        if root:
            s.append(root)
            root = root.left
        else:
            root = s.pop()
            mid_res_without_rec.append(root.data)
            root = root.right

mid_res_without_rec = []
mid_order_without_recursion(root)
print 'mid_res_without_rec:', mid_res_without_rec

后序遍历的非递归形式：

def post_order_without_recursion(root):
    s = []
    pre = None
    while root:
        while root.left:
            s.append(root)
            root = root.left
        while root and (not root.right or root.right == pre):
            post_res_without_rec.append(root.data)
            pre = root
            if not s:
                return
            root = s.pop()
        s.append(root)
        root = root.right

post_res_without_rec = []
post_order_without_recursion(root)
print 'post_res_without_rec:', post_res_without_rec

二叉树可以为空