Python实现二叉树递归遍历_递归算法遍历树 python

一. 介绍

1. 满二叉树

满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。

2. 完全二叉树

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点，如下图所示：

堆就是一棵完全二叉树，同时保证父子节点的顺序关系。

3. 二叉搜索树

二叉搜索树是一个有序树：

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉排序树

下面这两棵树都是二叉搜索树：

4. 平衡二叉搜索树

平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
如图：

最后一棵不是平衡二叉树，因为它的左右两个子树的高度差的绝对值超过了1。

二. 二叉树前中后序遍历

看如下中间节点的顺序，就可以发现，中间节点的顺序就是所谓的遍历方式：

• 前序遍历：中左右
• 中序遍历：左中右
• 后序遍历：左右中

举例如下图：

三. 二叉树定义

二叉树是一种基础数据结构，二叉树有两种存储方式顺序存储，和链式存储。顺序存储就是用数组来存，链式存储用链表存储，相对于链表二叉树的节点里多了一个指针， 有两个指针，指向左右孩子。

1. 链式存储

链式存储则是通过指针把分布在各个地址的节点串联一起，链式存储如图：

定义根节点代码如下：

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None
1
2
3
4
5

2. 顺序存储

用数组来存储二叉树，顺序存储的方式如图：

用数组来存储二叉树如何遍历的呢？

如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。

四. 二叉树递归遍历

介绍递归算法的三个要素。每次写递归，都按照这三要素来写，可以保证大家写出正确的递归算法：

1. 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。

2. 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

3. 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

1. 前序遍历实现

from typing import List

###树节点数据结构定义
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None
        
# 前序遍历-递归-LC144_二叉树的前序遍历
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        # 保存结果
        result = []
        
        def traversal(root: TreeNode):
            if root == None:
                return
            result.append(root.val) # 前序
            traversal(root.left)    # 左
            traversal(root.right)   # 右

        traversal(root)
        return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2. 中序遍历实现

from typing import List

###树节点数据结构定义
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

# 中序遍历-递归-LC94_二叉树的中序遍历
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        result = []

        def traversal(root: TreeNode):
            if root == None:
                return
            traversal(root.left)    # 左
            result.append(root.val) # 中序
            traversal(root.right)   # 右

        traversal(root)
        return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3. 后序遍历实现

from typing import List

###树节点数据结构定义
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

# 后序遍历-递归-LC145_二叉树的后序遍历
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        result = []

        def traversal(root: TreeNode):
            if root == None:
                return
            traversal(root.left)    # 左
            traversal(root.right)   # 右
            result.append(root.val) # 后序

        traversal(root)
        return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

五. 二叉树迭代遍历

1. 下一节：Python实现二叉树迭代遍历