代码随想录算法训练营第十四天|第六章二叉树：理论基础递归遍历迭代遍历统一迭代

Aria_记录

已于 2022-12-21 16:01:58 修改

阅读量90

点赞数

文章标签：算法

于 2022-12-20 16:12:49 首次发布

本文链接：https://blog.csdn.net/weixin_48111139/article/details/128380500

版权

一、理论基础

1、二叉树种类：满二叉树、完全二叉树、二叉搜索树、平衡二叉搜索树

满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。

这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。（二叉树的深度是指二叉树的所有结点中最深的结点所在的层数，如图即k=4，2^4-1=15个节点[同时也是最大节点数]）

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

前面两种树，都是没有数值的，而二叉搜索树是有数值的了，二叉搜索树是一个有序树。

二叉搜索树：

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

平衡二叉搜索树（也被称为AVL树）：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

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

2、二叉树的存储方式

分为两种：链式存储，顺序存储

链式存储：指针

顺序存储：数组

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

但是用链式表示的二叉树，更有利于我们理解，所以一般我们都是用链式存储二叉树。

用数组表示二叉树了解即可。

3、二叉树的遍历方式：有两种遍历方式，具体又分为以下

深度优先遍历
- 前序遍历（递归法，迭代法）
- 中序遍历（递归法，迭代法）
- 后序遍历（递归法，迭代法）
广度优先遍历
- 层次遍历（迭代法）

3.1深度优先遍历：

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

4、二叉树的定义

public class TreeNode {
    int val;
  	TreeNode left;
  	TreeNode right;
  	TreeNode() {}
  	TreeNode(int val) { this.val = val; }
  	TreeNode(int val, TreeNode left, TreeNode right) {
    		this.val = val;
    		this.left = left;
    		this.right = right;
  	}
}

二、递归遍历（必须掌握）

1、按照这三要素来写递归算法：

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

List<Integer> result = new ArrayList<Integer>();
        preorder(root, result);

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

if (root == null) {
            return;
        }

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

//以前序遍历为例：
result.add(root.val);
        preorder(root.left, result);
        preorder(root.right, result);

2、几个例子

2.1 144. 二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的前序遍历。

// 前序遍历·递归·LC144_二叉树的前序遍历
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        preorder(root, result);
        return result;
    }

    public void preorder(TreeNode root, List<Integer> result) {
        if (root == null) {
            return;
        }
        result.add(root.val);
        preorder(root.left, result);//递归枝点
        preorder(root.right, result);
    }
}

2.2 94. 二叉树的中序遍历

// 中序遍历·递归·LC94_二叉树的中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        inorder(root, res);
        return res;
    }

    void inorder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        inorder(root.left, list);
        list.add(root.val);             // 注意这一句
        inorder(root.right, list);
    }
}

2.3 145.二叉树的后续遍历

// 后序遍历·递归·LC145_二叉树的后序遍历
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        postorder(root, res);
        return res;
    }

    void postorder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        postorder(root.left, list);
        postorder(root.right, list);
        list.add(root.val);             // 注意这一句
    }
}

三、迭代遍历

递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。

1、前序遍历（中左右）：

前序遍历是中左右，每次先处理的是中间节点，那么先将根节点放入栈中，然后将右孩子加入栈，再加入左孩子。（注意栈的弹出顺序）

// -> 符号：是JDK8引入的Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）

参考：Java中的箭头-＞符号_日出前的千夜的博客-CSDN博客

JAVA中的Lambda表达式（“-＞“）用法_WYP@LML的博客-CSDN博客_java->

eg: node->right接收一个node变量，返回node对应的right


// 前序遍历顺序：中-左-右，入栈顺序：中-右-左
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();//存放遍历的结果
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();//定义一个栈，存放二叉树节点
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.right != null){
                stack.push(node.right);
            }
            if (node.left != null){
                stack.push(node.left);
            }
        }
        return result;
    }
}

2、后序遍历（左右中）：

后序遍历只需要前序遍历的代码稍作修改就可以了，（左右节点行互换即可），代码如下：

// 后序遍历顺序 左-右-中 入栈顺序：中-左-右 出栈顺序：中-右-左， 最后翻转结果
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            //先左后右
            if (node.left != null){
                stack.push(node.left);
            }
            if (node.right != null){
                stack.push(node.right);
            }
        }
        Collections.reverse(result);//反转
        return result;
    }
}

3、中序遍历（左中右）：

这个要复杂一些，首先访问的是根节点a，但是处理的不是根节点a，需要继续向下，直到d才开始处理。一路向左，直到访问到null节点，可知上一节点为叶子节点（即终端节点）。

// 中序遍历顺序: 左-中-右 入栈顺序： 左-右
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()){
           if (cur != null){
               stack.push(cur);
               cur = cur.left;//找到左边的叶子节点
           }else{
               cur = stack.pop();
               result.add(cur.val);
               cur = cur.right;
           }
        }
        return result;
    }
}