Python 实现二叉树前序,中序,后序,层次遍历

简介: 树是数据结构中非常重要的一种,主要的用途是用来提高查找效率,对于要重复查找的情况效果更佳,如二叉排序树、FP-树。另外可以用来提高编码效率,如哈弗曼树。

树是数据结构中非常重要的一种,主要的用途是用来提高查找效率,对于要重复查找的情况效果更佳,如二叉排序树、FP-树。另外可以用来提高编码效率,如哈弗曼树。

用 Python 实现树的构造和几种遍历算法。实现功能如下:

  • 树的构造
  • 递归实现先序遍历、中序遍历、后序遍历
  • 堆栈实现先序遍历、中序遍历、后序遍历
  • 队列实现层次遍历


# -*- coding=utf-8 -*-
class Node(object):
    """节点类"""
    def __init__(self, element=-1, l_child=None, r_child=None):
        self.element = element
        self.l_child = l_child
        self.r_child = r_child
class Tree(object):
    """树类"""
    def __init__(self):
        self.root = Node()
        self.queue = []
    def add_node(self, element):
        """为树添加节点"""
        node = Node(element)
        # 如果树是空的,则对根节点赋值
        if self.root.element == -1:
            self.root = node
            self.queue.append(self.root)
        else:
            tree_node = self.queue[0]
            # 此结点没有左子树,则创建左子树节点
            if tree_node.l_child is None:
                tree_node.l_child = node
                self.queue.append(tree_node.l_child)
            else:
                tree_node.r_child = node
                self.queue.append(tree_node.r_child)
                # 如果该结点存在右子树,将此节点丢弃
                self.queue.pop(0)
    def front_recursion(self, root):
        """利用递归实现树的前序遍历"""
        if root is None:
            return
        print root.element,
        self.front_recursion(root.l_child)
        self.front_recursion(root.r_child)
    def middle_recursion(self, root):
        """利用递归实现树的中序遍历"""
        if root is None:
            return
        self.middle_recursion(root.l_child)
        print root.element,
        self.middle_recursion(root.r_child)
    def back_recursion(self, root):
        """利用递归实现树的后序遍历"""
        if root is None:
            return
        self.back_recursion(root.l_child)
        self.back_recursion(root.r_child)
        print root.element,
    @staticmethod
    def front_stack(root):
        """利用堆栈实现树的前序遍历"""
        if root is None:
            return
        stack = []
        node = root
        while node or stack:
            # 从根节点开始,一直找它的左子树
            while node:
                print node.element,
                stack.append(node)
                node = node.l_child
            # while结束表示当前节点node为空,即前一个节点没有左子树了
            node = stack.pop()
            # 开始查看它的右子树
            node = node.r_child
    @staticmethod
    def middle_stack(root):
        """利用堆栈实现树的中序遍历"""
        if root is None:
            return
        stack = []
        node = root
        while node or stack:
            # 从根节点开始,一直找它的左子树
            while node:
                stack.append(node)
                node = node.l_child
            # while结束表示当前节点node为空,即前一个节点没有左子树了
            node = stack.pop()
            print node.element,
            # 开始查看它的右子树
            node = node.r_child
    @staticmethod
    def back_stack(root):
        """利用堆栈实现树的后序遍历"""
        if root is None:
            return
        stack1 = []
        stack2 = []
        node = root
        stack1.append(node)
        # 这个while循环的功能是找出后序遍历的逆序,存在stack2里面
        while stack1:
            node = stack1.pop()
            if node.l_child:
                stack1.append(node.l_child)
            if node.r_child:
                stack1.append(node.r_child)
            stack2.append(node)
        # 将stack2中的元素出栈,即为后序遍历次序
        while stack2:
            print stack2.pop().element,
    @staticmethod
    def level_queue(root):
        """利用队列实现树的层次遍历"""
        if root is None:
            return
        queue = []
        node = root
        queue.append(node)
        while queue:
            node = queue.pop(0)
            print node.element,
            if node.l_child is not None:
                queue.append(node.l_child)
            if node.r_child is not None:
                queue.append(node.r_child)
if __name__ == '__main__':
    """主函数"""
    # 生成十个数据作为树节点
    elements = range(10)
    tree = Tree()
    for elem in elements:
        tree.add_node(elem)
    print '队列实现层次遍历:'
    tree.level_queue(tree.root)
    print '\n\n递归实现前序遍历:'
    tree.front_recursion(tree.root)
    print '\n递归实现中序遍历:'
    tree.middle_recursion(tree.root)
    print '\n递归实现后序遍历:'
    tree.back_recursion(tree.root)
    print '\n\n堆栈实现前序遍历:'
    tree.front_stack(tree.root)
    print '\n堆栈实现中序遍历:'
    tree.middle_stack(tree.root)
    print '\n堆栈实现后序遍历:'
    tree.back_stack(tree.root)


目录
相关文章
|
2月前
|
Python
【Leetcode刷题Python】剑指 Offer 32 - III. 从上到下打印二叉树 III
本文介绍了两种Python实现方法,用于按照之字形顺序打印二叉树的层次遍历结果,实现了在奇数层正序、偶数层反序打印节点的功能。
44 6
|
2月前
|
Python
【Leetcode刷题Python】114. 二叉树展开为链表
LeetCode上114号问题"二叉树展开为链表"的Python实现,通过先序遍历二叉树并调整节点的左右指针,将二叉树转换为先序遍历顺序的单链表。
23 3
【Leetcode刷题Python】114. 二叉树展开为链表
|
2月前
|
索引 Python
【Leetcode刷题Python】从列表list中创建一颗二叉树
本文介绍了如何使用Python递归函数从列表中创建二叉树,其中每个节点的左右子节点索引分别是当前节点索引的2倍加1和2倍加2。
38 7
|
2月前
|
存储 算法 Python
【Leetcode刷题Python】297. 二叉树的序列化与反序列化
LeetCode第297题"二叉树的序列化与反序列化"的Python语言解决方案,包括序列化二叉树为字符串和反序列化字符串为二叉树的算法实现。
22 5
|
2月前
|
Python
【Leetcode刷题Python】236. 二叉树的最近公共祖先
LeetCode上236号问题"二叉树的最近公共祖先"的Python实现,使用递归方法找到两个指定节点的最近公共祖先。
29 5
|
2月前
|
Python
【Leetcode刷题Python】剑指 Offer 32 - II. 从上到下打印二叉树 II
本文提供了一种Python实现方法,用于层次遍历二叉树并按层打印结果,每层节点按从左到右的顺序排列,每层打印到一行。
30 3
|
2月前
|
Python
【Leetcode刷题Python】199. 二叉树的右视图
LeetCode上199号问题"二叉树的右视图"的Python实现,通过深度优先搜索算法按层序从右向左访问节点,以获取每层的最右边节点的值。
21 4
|
2月前
|
Python
【Leetcode刷题Python】剑指 Offer 32 - I. 从上到下打印二叉树
本文介绍了使用Python实现从上到下打印二叉树的解决方案,采用层次遍历的方法,利用队列进行节点的访问。
30 2
|
2月前
|
Python
【Leetcode刷题Python】105. 从前序与中序遍历序列构造二叉树
LeetCode上105号问题"从前序与中序遍历序列构造二叉树"的Python实现,通过递归方法根据前序和中序遍历序列重建二叉树。
18 3
|
2月前
|
存储 Python
【Leetcode刷题Python】103. 二叉树的锯齿形层序遍历
LeetCode上103号问题"二叉树的锯齿形层序遍历"的Python实现,使用了双端队列来实现层与层之间交替的遍历顺序。
16 3
下一篇
无影云桌面