python二叉树遍历_先序中序后序_深度优先广度优先_非递归先序非递归中序

Guff_hys

已于 2024-01-29 02:40:51 修改

阅读量1.1w

点赞数 33

文章标签： python 深度优先宽度优先算法图论数据结构广度优先

于 2023-11-23 10:49:53 首次发布

本文链接：https://blog.csdn.net/HYSliuliuliu/article/details/134571124

版权

总代码：

class Node:
    def __init__(self,data):
        self.data = data
        self.lchild = None
        self.rchild = None
class Tree:
    def __init__(self):
        self.root = None
    def add(self,data):
        node = Node(data)
        if self.root is None:
            self.root = node
            return
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            if cur_node.lchild is None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)
            if cur_node.rchild is None:
                cur_node.rchild = node
                return
            else:
                queue.append(cur_node.rchild)
    def breadth_travel(self):
        """广度遍历"""
        if self.root == None:
            return
        queue=[self.root]
        while queue:
            cur_node = queue.pop(0)
            print(cur_node.data,end=" ")
            if cur_node.lchild is not None:
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                queue.append(cur_node.rchild)

    def dfs(self,root):
        if root is None:
            return
        print(root.data)
        self.dfs(root.left)
        self.dfs(root.right)
    def preorder(self, root):
        """先序遍历"""
        if root is None:
            return
        print(root.data, end=" ")
        self.preorder(root.lchild)
        self.preorder(root.rchild)
    def inorder(self, root):
        """中序遍历"""
        if root is None:
            return
        self.inorder(root.lchild)
        print(root.data, end=" ")
        self.inorder(root.rchild)
    def postorder(self, root):
        """后序遍历"""
        if root is None:
            return
        self.postorder(root.lchild)
        self.postorder(root.rchild)
        print(root.data, end=" ")

    def no_preorder(self,root):
        """非递归的先序遍历"""
        if root==None:
            return
        alist=[root]
        while alist:
            cur=alist.pop()
            print(cur.data)
            if cur.rchild != None:
                alist.append(cur.rchild)
            if cur.lchild != None:
                alist.append(cur.lchild)
    def no_inorder(self,root):
        cur=root
        alist=[]
        while cur or alist:
            if cur!=None:
                alist.append(cur)
                cur=cur.lchild
            else:
                cur=alist.pop()
                print(cur.data)
                cur=cur.rchild





def same_tree(t1,t2):
    """两棵树相似"""
    if t1==None and t2==None:
        return True
    if t1==None and t2!=None:
        return False
    if t1!=None and t2==None:
        return False
    # if t1.data!=t2.data:
    #     return False
    else:
        like_l=same_tree(t1.lchild,t2.lchild)
        like_r=same_tree(t1.rchild,t2.rchild)
        return (like_l and like_r)


if __name__=="__main__":
    tree=Tree()
    tree.add(0)
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)
    tree.add(6)
    tree.add(7)
    tree.add(8)
    tree.add(9)
    print("广度优先遍历")
    tree.breadth_travel()
    print("")
    print("先序遍历")
    tree.preorder(tree.root)
    print("")
    print("中序遍历")
    tree.inorder(tree.root)
    print("")
    print("后序遍历")
    tree.postorder(tree.root)
    print("")
    # tree2=Tree()
    # tree2.add(0)
    # tree2.add(1)
    # tree2.add(2)
    # # tree.add(3)
    # # tree.add(4)
    # # tree.add(5)
    # # tree.add(6)
    # # tree.add(7)
    # # tree.add(8)
    # # tree.add(9)
    # print(same_tree(tree.root,tree2.root))
    # tree.no_preorder(tree.root)
    tree.no_preorder(tree.root)
    print("...........................")
    tree.no_inorder(tree.root)

python 二叉树广度优先遍历：

广度优先遍历（BFS）是一种用于遍历树或图的算法，它从根节点开始，逐层遍历每个节点的所有子节点。在二叉树中，广度优先遍历按照从上到下、从左到右的顺序遍历节点。

在Python中，可以使用队列来实现二叉树的广度优先遍历。具体步骤如下：

创建一个空队列，并将根节点加入队列中。
从队列中取出一个节点，并访问该节点。
将该节点的左子节点和右子节点（如果存在）依次加入队列中。
重复步骤2和步骤3，直到队列为空。

下面是一个示例代码，实现了二叉树的广度优先遍历：

    def breadth_travel(self):
        """广度遍历"""
        if self.root == None:
            return
        queue=[self.root]
        while queue:
            cur_node = queue.pop(0)
            print(cur_node.data,end=" ")
            if cur_node.lchild is not None:
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                queue.append(cur_node.rchild)

python 二叉树深度优先遍历：

在Python中，二叉树的深度优先遍历（DFS）有三种常见的方式：前序遍历、中序遍历和后序遍历。

前序遍历（Preorder Traversal）：先访问根节点，然后递归地前序遍历左子树，最后递归地前序遍历右子树。
中序遍历（Inorder Traversal）：先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。
后序遍历（Postorder Traversal）：先递归地后序遍历左子树，然后递归地后序遍历右子树，最后访问根节点。

以下是一个示例代码，演示了如何实现二叉树的深度优先遍历：

先序遍历：

二叉树的先序遍历是指先访问根节点，然后递归地先序遍历左子树，最后递归地先序遍历右子树。具体步骤如下：

1. 访问根节点
2. 递归地先序遍历左子树
3. 递归地先序遍历右子树

这样就可以按照根节点、左子树、右子树的顺序遍历整棵二叉树。

    def preorder(self, root):
        """先序遍历"""
        if root is None:
            return
        print(root.data, end=" ")
        self.preorder(root.lchild)
        self.preorder(root.rchild)

中序遍历：

二叉树的中序遍历是指先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。具体步骤如下：

1. 递归地中序遍历左子树
2. 访问根节点
3. 递归地中序遍历右子树

这样就可以按照左子树、根节点、右子树的顺序遍历整棵二叉树。

    def inorder(self, root):
        """中序遍历"""
        if root is None:
            return
        self.inorder(root.lchild)
        print(root.data, end=" ")
        self.inorder(root.rchild)

后序遍历：

二叉树的后序遍历是指先递归地后序遍历左子树，然后递归地后序遍历右子树，最后访问根节点。具体步骤如下：

1. 递归地后序遍历左子树
2. 递归地后序遍历右子树
3. 访问根节点

这样就可以按照左子树、右子树、根节点的顺序遍历整棵二叉树。

    def postorder(self, root):
        """后序遍历"""
        if root is None:
            return
        self.postorder(root.lchild)
        self.postorder(root.rchild)
        print(root.data, end=" ")

非递归的先序遍历：

非递归的先序遍历可以使用一个辅助栈来实现，而不是使用列表。不过，如果一定要使用列表来实现非递归的先序遍历，可以模拟栈的操作。

具体步骤如下：

1. 创建一个空列表作为栈。
2. 将根节点压入栈中。
3. 循环执行以下步骤，直到栈为空：
a. 弹出栈顶节点，访问该节点。
b. 如果该节点的右子节点不为空，则将右子节点压入栈中（注意先压入右子节点，再压入左子节点）。
c. 如果该节点的左子节点不为空，则将左子节点压入栈中。

这样就可以使用列表来模拟栈的操作，实现非递归的先序遍历。

    def no_preorder(self,root):
        """非递归的先序遍历"""
        if root==None:
            return
        alist=[root]
        while alist:
            cur=alist.pop()
            print(cur.data)
            if cur.rchild != None:
                alist.append(cur.rchild)
            if cur.lchild != None:
                alist.append(cur.lchild)

非递归的中序遍历：

非递归的中序遍历可以使用一个辅助栈来实现，而不是使用列表。不过，如果一定要使用列表来实现非递归的中序遍历，可以模拟栈的操作。

具体步骤如下：

1. 创建一个空列表作为栈。
2. 将根节点压入栈中。
3. 循环执行以下步骤，直到栈为空：
a. 将当前节点的左子节点依次压入栈中，直到最左侧的叶子节点。
b. 弹出栈顶节点，访问该节点。
c. 将当前节点指向右子节点，重复步骤a。

这样就可以使用列表来模拟栈的操作，实现非递归的中序遍历。

    def no_inorder(self,root):
        cur=root
        alist=[]
        while cur or alist:
            if cur!=None:
                alist.append(cur)
                cur=cur.lchild
            else:
                cur=alist.pop()
                print(cur.data)
                cur=cur.rchild

Guff_hys

关注

33
点赞
踩
23

收藏

觉得还不错? 一键收藏
打赏
0
评论
python二叉树遍历_先序中序后序_深度优先广度优先_非递归先序非递归中序

总代码：python 二叉树广度优先遍历：python 二叉树深度优先遍历：先序遍历：中序遍历：后序遍历：非递归的先序遍历：非递归的中序遍历：python 二叉树广度优先遍历：广度优先遍历（BFS）是一种用于遍历树或图的算法，它从根节点开始，逐层遍历每个节点的所有子节点。在二叉树中，广度优先遍历按照从上到下、从左到右的顺序遍历节点。在Python中，可以使用队列来实现二叉树的广度优先遍历。具体步骤如下：下面是一个示例代码，实现了二叉树的广度优先遍历： python 二叉树深度优先遍历：在
复制链接

扫一扫