python实现二叉树及其七种遍历方式(递归+非递归)

1、二叉树的遍历方式?

前序遍历:根左右

中序遍历:左根右

后序遍历:左右根

层次遍历:从上到下,从左到右

2、python新建一个二叉树及其七种遍历(递归和非递归)

class Node():
    #节点类
    def __init__(self,data = -1):
        self.data = data
        self.left = None
        self.right = None
class Tree():
    #树类
    def __init__(self):
        self.root = Node()

    def add(self,data):
        # 为树加入节点
        node  = Node(data)
        if self.root.data == -1:        #如果树为空,就对根节点赋值
            self.root = node
        else:
            myQueue = []
            treeNode = self.root
            myQueue.append(treeNode)
            while myQueue:              #对已有的节点进行层次遍历
                treeNode = myQueue.pop(0)
                if not treeNode.left:
                    treeNode.left = node
                    return
                elif not treeNode.right:
                    treeNode.right = node
                    return
                else:
                    myQueue.append(treeNode.left)
                    myQueue.append(treeNode.right)

    def pre_order_recursion(self,root):     #递归实现前序遍历
        if not root:
            return
        print root.data,
        self.pre_order_recursion(root.left)
        self.pre_order_recursion(root.right)

    def pre_order_stack(self,root):         #堆栈实现前序遍历(非递归)
        if not root:
            return
        myStack = []
        node = root
        while myStack or node:
            while node:       #从根节点开始,一直寻找他的左子树
                print node.data,
                myStack.append(node)
                node = node.left
            node = myStack.pop()    #while结束表示当前节点node为空,即前一个节点没有左子树了
            node = node.right       #开始查看它的右子树

    def in_order_recursion(self,root):      #递归实现中序遍历
        if not root:
            return
        self.in_order_recursion(root.left)
        print root.data,
        self.in_order_recursion(root.right)

    def in_order_stack(self,root):        #堆栈实现中序遍历(非递归)
        if not root:
            return
        myStack = []
        node = root
        while myStack or node:     #从根节点开始,一直寻找它的左子树
            while node:
                myStack.append(node)
                node = node.left
            node = myStack.pop()
            print node.data,
            node = node.right


    def post_order_recursion(self,root):     #递归实现后序遍历
        if not root:
            return
        self.post_order_recursion(root.left)
        self.post_order_recursion(root.right)
        print root.data,

    def post_order_stack(self, root):  # 堆栈实现后序遍历(非递归)
        # 先遍历根节点,再遍历右子树,最后是左子树,这样就可以转化为和先序遍历一个类型了,最后只把遍历结果逆序输出就OK了。
        if not root:
            return
        myStack1 = []
        myStack2 = []
        node = root
        while myStack1 or node:
            while node:
                myStack2.append(node)
                myStack1.append(node)
                node = node.right
            node = myStack1.pop()
            node = node.left
        while myStack2:
            print myStack2.pop().data,

    def level_order_queue(self,root):       #队列实现层次遍历(非递归)
        if not root :
            return
        myQueue = []
        node = root
        myQueue.append(node)
        while myQueue:
            node = myQueue.pop(0)
            print node.data,
            if node.left:
                myQueue.append(node.left)
            if node.right:
                myQueue.append(node.right)

if __name__ == '__main__':
    #主函数
    datas = [2,3,4,5,6,7,8,9]
    tree = Tree()          #新建一个树对象
    for data in datas:
        tree.add(data)      #逐个加入树的节点

    print '递归实现前序遍历:'
    tree.pre_order_recursion(tree.root)

    print '\n堆栈实现前序遍历'
    tree.pre_order_stack(tree.root)

    print "\n\n递归实现中序遍历:"
    tree.in_order_recursion(tree.root)

    print "\n堆栈实现中序遍历:"
    tree.in_order_stack(tree.root)

    print '\n\n递归实现后序遍历:'
    tree.post_order_recursion(tree.root)

    print '\n堆栈实现后序遍历:'
    tree.post_order_stack(tree.root)

    print '\n\n队列实现层次遍历:'
    tree.level_order_queue(tree.root)

3、二叉树的序列化和反序列化

1、二叉树—–>字符串(序列化)

2、字符串—–>二叉树(反序列化)

序列化的方式:

根据先序遍历序列化

根据中序遍历序列化

根据后序遍历序列化

按层序列化

这里以先序遍历为例子:

  1. 假设序列化结果为str,初始str为空字符串
  2. 先序遍历二叉树时如果遇到空节点,在str末端加上”#!”
  3. 如果遇到不为空的节点,假设节点值为3,就在str的末尾加上”3!”

(这里加上!的原因是为了防止产生歧义,比如说12和1,2,序列化后都是12)

反序列化:

1、将字符串转化为数组

1、选择用什么的遍历方式序列化,就选择用什么样的方式反序列化

2、一棵树序列化的结果是唯一的,唯一的结果生成的二叉树也是唯一的

按层遍历的方式对二叉树进行序列化

1、用队列进行二叉树的按层遍历,即宽度优先遍历。

2、除了访问节点的顺序是按层遍历之外,对结果字符串的处理,与之前介绍的处理方式一样。

参考文献:
1、https://blog.csdn.net/lq_lq314/article/details/79176953 2018.8.6

阅读更多

扫码向博主提问

JohnieLi

深度学习小白,寻找一起学习的道友
  • 擅长领域:
  • 图像处理
  • 深度学习
去开通我的Chat快问
想对作者说点什么? 我来说一句
相关热词

没有更多推荐了,返回首页