python实现二叉树的遍历以及基本操作

主要内容:

  1. 二叉树遍历(先序、中序、后序、宽度优先遍历)的迭代实现和递归实现;
  2. 二叉树的深度,二叉树到叶子节点的所有路径;

首先,先定义二叉树类(python3),代码如下:

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

内容1:二叉树的遍历

????????二叉树的遍历分深度优先遍历(DFS)和宽度优先遍历(BFS)。其中深度优先遍历又分为先序遍历,中序遍历,后序遍历。因为二叉树是递归类数据结构,因此大部分关于二叉树的操作都可以通过递归实现。下面将介绍二叉树几种遍历的实现代码以及思路。

1.1 先序遍历:

????????遍历顺序:根节点——左子节点——右子节点(A-B-D-E-C-F)。

递归实现:

def preorder(root):
    if not root:
        return
    print(root.val)
    preorder(root.left)
    preorder(root.right) 

迭代实现:

def preorder(root):
    stack = [root]
    while stack:
        s = stack.pop()
        if s:
            print(s.val)
            stack.append(s.right)
            stack.append(s.left)

1.2 中序遍历

????????遍历顺序:左子节点——根节点——右子节点(D-B-E-A-C-F)

递归实现:

def inorder(root):
    if not root:
        return
    inorder(root.left)
    print(root.val)
    inorder(root.right)

迭代实现:

def inorder(root):
    stack = []
    while stack or root:
        while root:
            stack.append(root)
            root = root.left
        root = stack.pop()
        print(root.val)
        root = root.right

1.3 后序遍历

????????遍历顺序:左子节点——右子节点——根节点(D-E-B-F-C-A)

递归实现:

def postorder(root):
    if not root:
        return
    postorder(root.left)
    postorder(root.right)
    print(root.val)

迭代实现:

def postorder(root):
    stack = []
    while stack or root:
        while root:                 # 下行循环,直到找到第一个叶子节点

            stack.append(root)
            if root.left:           # 能左就左,不能左就右

                root = root.left
            else:
                root = root.right
        s = stack.pop()
        print(s.val)
        #如果当前节点是上一节点的左子节点,则遍历右子节点

        if stack and s == stack[-1].left: 

            root = stack[-1].right
        else:
            root = None

1.4 层次遍历

????????遍历顺序:一层一层的遍历(A-B-C-D-E-F)

迭代实现:

def BFS(root):
    queue = [root]
    while queue:
        n = len(queue)
        for i in range(n):
            q = queue.pop(0)
            if q:
                print(q.val)
                queue.append(q.left if q.left else None)
                queue.append(q.right if q.right else None)

内容2:基本操作

2.1 二叉树的最大深度

????????基本思路就是递归,当前树的最大深度等于(1+max(左子树最大深度,右子树最大深度))。代码如下:

def maxDepth(root):

    if not root:
        return 0
    return 1+max(maxDepth(root.left),maxDepth(root.right))

2.2 二叉树的最小深度

????????最小深度是从根节点到最近叶子节点的最短路径上的节点数量。可以通过递归求左右节点的最小深度的较小值,也可以层序遍历找到第一个叶子节点所在的层数。

递归方法:

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        if not root.left and not root.right:
            return 1
        if not root.right:
            return 1+self.minDepth(root.left)
        if not root.left:
            return 1+self.minDepth(root.right)
        return 1+min(self.minDepth(root.left),self.minDepth(root.right))

迭代方法:

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root: return 0
        ans,count = [root],1
        while ans:
            n = len(ans)
            for i in range(n):
                r = ans.pop(0)
                if r:
                    if not r.left and not r.right:
                        return count
                    ans.append(r.left if r.left else [])
                    ans.append(r.right if r.right else [])
            count+=1 

2.3 二叉树的所有路径

????????根节点到叶子节点的所有路径。

def traverse(node):
    if not node.left and not node.right:
        return [str(node.val)]
    left, right = [], []
    if node.left:
        left = [str(node.val) + x for x in traverse(node.left)]
    if node.right:
        right = [str(node.val) + x for x in traverse(node.right)]

    return left + right

原文地址:https://www.cnblogs.com/anzhengyu/p/11083568.html

时间: 2024-11-08 19:30:45

python实现二叉树的遍历以及基本操作的相关文章

javascript实现数据结构: 树和二叉树,二叉树的遍历和基本操作

树型结构是一类非常重要的非线性结构.直观地,树型结构是以分支关系定义的层次结构. 树在计算机领域中也有着广泛的应用,例如在编译程序中,用树来表示源程序的语法结构:在数据库系统中,可用树来组织信息:在分析算法的行为时,可用树来描述其执行过程等等. 下面讲解的内容完整代码在这:https://github.com/LukeLin/data-structure-with-js/blob/master/Binary%20tree/BinaryTree.js 首先看看树的一些概念: 1.树(Tree)是n

Python实现二叉树的遍历

class BinaryTree(object):     def __init__(self, value=None, left=None, right=None):         self.value = value         self.left = left         self.right = right     def rebuild(self, preOrder, inOrder):         """         根据前序列表和中序列表,重建

python中创建和遍历二叉树

python创建和遍历二叉树,可以使用递归的方式,源代码如下: #!/usr/bin/python class node(): def __init__(self,k=None,l=None,r=None): self.key=k; self.left=l; self.right=r; def create(root): a=raw_input('enter a key:'); if a is '#': root=None; else: root=node(k=a); root.left=cre

python实现二叉树遍历算法

说起二叉树的遍历,大学里讲的是递归算法,大多数人首先想到也是递归算法.但作为一个有理想有追求的程序员.也应该学学非递归算法实现二叉树遍历.二叉树的非递归算法需要用到辅助栈,算法着实巧妙,令人脑洞大开. 以下直入主题: 定义一颗二叉树,请看官自行想象其形状, class BinNode( ): def __init__( self, val ): self.lchild = None self.rchild = None self.value = val binNode1 = BinNode( 1

Python与数据结构[3] -> 树/Tree[0] -> 二叉树及遍历二叉树的 Python 实现

二叉树 / Binary Tree 二叉树是树结构的一种,但二叉树的每一个节点都最多只能有两个子节点. Binary Tree: 00 |_____ | | 00 00 |__ |__ | | | | 00 00 00 00 对于二叉树的遍历,主要有以下三种基本遍历方式: 先序遍历:先显示节点值,再显示左子树和右子树 中序遍历:先显示左子树,再显示节点值和右子树 后序遍历:先显示左子树和右子树,再显示节点值 下面将用代码构建一个二叉树,并实现三种遍历方式, 完整代码 1 class TreeNo

数据结构第三部分:树与树的表示、二叉树及其遍历、二叉搜索树、平衡二叉树、堆、哈夫曼树、集合及其运算

参考:浙大数据结构(陈越.何钦铭)课件 1.树与树的表示 什么是树? 客观世界中许多事物存在层次关系 人类社会家谱 社会组织结构 图书信息管理 分层次组织在管理上具有更高的效率! 数据管理的基本操作之一:查找(根据某个给定关键字K,从集合R 中找出关键字与K 相同的记录).一个自然的问题就是,如何实现有效率的查找? 静态查找:集合中记录是固定的,没有插入和删除操作,只有查找 动态查找:集合中记录是动态变化的,除查找,还可能发生插入和删除 静态查找——方法一:顺序查找(时间复杂度O(n)) int

[数据结构] 二叉树的建立及其基本操作

如图: 代码: #include <iostream> #include <stdio.h> #include <algorithm> #include <string.h> using namespace std; char ch; typedef struct BinNode { char data; struct BinNode *lchild,*rchild; }BinNode,*BinTree; //二叉树链式存储结构 void CreateBin

数据结构 - 二叉树的遍历

中序遍历二叉树 1 递归算法 算法的递归定义是: 若二叉树为空,则遍历结束:否则 ⑴ 中序遍历左子树(递归调用本算法): ⑵ 访问根结点: ⑶ 中序遍历右子树(递归调用本算法). 中序遍历的递归算法 void InorderTraverse(BTNode *T) { if (T==NULL) return: InorderTraverse(T->Lchild) ; visit(T->data) ; /* 访问根结点 */ InorderTraverse(T->Rchild) ; } 2

二叉树的遍历(基于栈的非递归方式实现)

在写二叉树的时候如果用递归实现二叉树的遍历很简单,但是用非递归来实现二叉树的遍历就不那么简单了需要一些技巧. 那为什么还要非递归实现呢?个人理解:如果树的高度很大,超过了允许递归的次数,那么就会出错,比如我记得python只允许递归100次(不知道记错没) 这时候用迭代就要保险的多,不会出错. 下面先来做基本的准备说明: 1 #include<iostream> 2 #include<stack> 3 4 #define null NULL 5 6 template<type