算法训练营day13|二叉树|理论基础,递归遍历,迭代遍历,统一迭代

已于 2023-11-03 20:53:12 修改
阅读量68 收藏
点赞数
文章标签： java
于 2023-10-29 22:32:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TS_xiaolei/article/details/134109322
版权

1.知识点

1.1基础知识

1.1.1二叉树的种类

1.1.1满二叉树

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

如图:

这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树

1.1.2完全二叉树

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

1.1.3二叉搜索树:BST

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

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

下面这两棵树都是搜索树

1.1.4平衡二叉搜索树:Balanced BST

平衡二叉搜索树的实现具有代表性的有AVL树,红黑树,SB树

1.1.4.1AVL树

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

如图:

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

1.1.4.2红黑树

1.1.4.3SB树

1.1.2二叉树的存储方式

二叉树可以链式存储，也可以顺序存储

链式存储:通过指针实现

顺序存储:通过数组实现

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

1.1.3二叉树的遍历方式

二叉树的遍历方式有两种方式:一种是深度优先遍历,广度优先遍历

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

这里前中后，其实指的就是中间节点的遍历顺序

1.1.4二叉树的定义

二叉树一个节点的信息包括:value,leftChild,rightChild

1.2递归遍历

1.2.1递归3要素

1.确定递归函数的参数和返回值

2.确定终止条件

3.确定单层递归的逻辑

1.2.2前序遍历

package daimasuixiangshuati.day13_erchashu;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author LeiGe
 * @Date 2023/11/2
 * @Description todo
 */
public class ErChaShuDeQianXuBianLi144_DiGui_1 {
    /**
     * 方法1:前序遍历-递归法
     *
     * @param root
     * @return
     */
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        dfs(root, result);
        return result;
    }

    private void dfs(TreeNode root, ArrayList<Integer> result) {
        if (root == null) {
            return;
        }

        // 中 左 右
        result.add(root.val);
        dfs(root.left, result);
        dfs(root.right, result);
    }

    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.2.3中序遍历

package daimasuixiangshuati.day13_erchashu;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author LeiGe
 * @Date 2023/11/2
 * @Description todo
 */
public class ErChaShuDeZhongXuBianLi94_DiGui_1 {

    /**
     * 法1:中序遍历-递归法
     *
     * @param root
     * @return
     */
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        dfs(root, result);
        return result;
    }

    private void dfs(TreeNode root, ArrayList<Integer> result) {
        if (root == null) {
            return;
        }

        // 左 中 右
        dfs(root.left, result);
        result.add(root.val);
        dfs(root.right, result);
    }

    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.2.4后序遍历

package daimasuixiangshuati.day13_erchashu;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author LeiGe
 * @Date 2023/11/2
 * @Description todo
 */
public class ErChaShuDeHouXuBianLi145_DiGui_1 {
    /**
     * 法1:后序遍历-递归法
     *
     * @param root
     * @return
     */
    public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        dfs(root, result);
        return result;
    }

    private void dfs(TreeNode root, ArrayList<Integer> result) {
        if (root == null) {
            return;
        }

        // 左 右 中
        dfs(root.left, result);
        dfs(root.right, result);
        result.add(root.val);
    }

    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.3迭代遍历

1.3.1前序遍历

package daimasuixiangshuati.day13_erchashu;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * @Author LeiGe
 * @Date 2023/11/2
 * @Description todo
 */
public class ErChaShuDeQianXuBianLi144_DieDai_2 {
    /**
     * 方法1:前序遍历-迭代法-通过栈实现
     *
     * @param root
     * @return
     */
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if (root == null) {
            return result;
        }

        // 加入头节点
        stack.push(root);

        while (!stack.isEmpty()) {
            // 中
            TreeNode peekNode = stack.pop();
            result.add(peekNode.val);

            // 右:空节点不如栈
            if (peekNode.right != null) {
                stack.push(peekNode.right);
            }

            // 左边:空节点不如栈
            if (peekNode.left != null) {
                stack.push(peekNode.left);
            }
        }

        return result;
    }

    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.3.2后序遍历

后序遍历就是将前序遍历的结果翻转即可

package daimasuixiangshuati.day13_erchashu;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;

/**
 * @Author LeiGe
 * @Date 2023/11/2
 * @Description todo
 */
public class ErChaShuDeHouXuBianLi145_DieDai_2 {
    /**
     * 方法1:后序遍历-迭代法-通过栈实现
     * 将先序遍历的结果翻转就是后续遍历
     *
     * @param root
     * @return
     */
    public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if (root == null) {
            return result;
        }

        // 加入头节点
        stack.push(root);

        while (!stack.isEmpty()) {
            // 中
            TreeNode peekNode = stack.pop();
            result.add(peekNode.val);

            // 左边:空节点不如栈
            if (peekNode.left != null) {
                stack.push(peekNode.left);
            }

            // 右:空节点不如栈
            if (peekNode.right != null) {
                stack.push(peekNode.right);
            }
        }
        Collections.reverse(result);
        return result;
    }

    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.3.3中序遍历

中序遍历和前序遍历逻辑不太一样,因为遍历的顺序和处理的顺序不一致

package daimasuixiangshuati.day13_erchashu;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * @Author LeiGe
 * @Date 2023/11/2
 * @Description todo
 */
public class ErChaShuDeZhongXuBianLi94_DieDai_2 {
    /**
     * 方法1:中序遍历-迭代法-通过栈实现
     *
     * @param root
     * @return
     */
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<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 {
                TreeNode tmp = stack.pop();
                // 中
                result.add(tmp.val);
                // 右
                cur = tmp.right;
            }
        }
        return result;
    }

    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.4统一迭代

为了解决访问节点和处理节点顺序不一致的问题,那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。

1.4.1前序遍历

package daimasuixiangshuati.day13_erchashu;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * @Author LeiGe
 * @Date 2023/11/2
 * @Description todo
 */
public class ErChaShuDeQianXuBianLi144_TongYiDieDai_3 {
    /**
     * 方法1:前序遍历-统一迭代法:标记法
     *
     * @param root
     * @return
     */
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();

        if (root != null) {
            stack.push(root);
        }

        while (!stack.isEmpty()) {
            TreeNode peekNode = stack.peek();

            if (peekNode != null) {
                // 将该节点弹出,避免重复操作,下面将 右左中节点添加到栈中
                stack.pop();

                // 放入右节点
                if (peekNode.right != null) {
                    stack.push(peekNode.right);
                }

                // 放入左节点
                if (peekNode.left != null) {
                    stack.push(peekNode.left);
                }

                // 放入中间节点,中间节点访问过,但是还没有处理,加入空节点标记
                stack.push(peekNode);
                stack.push(null);
            } else {
                // 弹出空节点
                stack.pop();
                // 重新取出栈中元素,加入到结果中
                TreeNode node = stack.pop();
                result.add(node.val);
            }
        }
        return result;
    }

    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.4.2中序遍历

package daimasuixiangshuati.day13_erchashu;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * @Author LeiGe
 * @Date 2023/11/2
 * @Description todo
 */
public class ErChaShuDeZhongXuBianLi94_TongYiDieDai_3 {
    /**
     * 方法1:中序遍历-统一迭代法:标记法
     *
     * @param root
     * @return
     */
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();

        if (root != null) {
            stack.push(root);
        }

        while (!stack.isEmpty()) {
            TreeNode peekNode = stack.peek();

            if (peekNode != null) {
                // 将该节点弹出,避免重复操作,下面将 右中左节点添加到栈中
                stack.pop();

                // 放入右节点
                if (peekNode.right != null) {
                    stack.push(peekNode.right);
                }

                // 放入中间节点,中间节点访问过,但是还没有处理,加入空节点标记
                stack.push(peekNode);
                stack.push(null);

                // 放入左节点
                if (peekNode.left != null) {
                    stack.push(peekNode.left);
                }
            } else {
                // 弹出空节点
                stack.pop();
                // 重新取出栈中元素,加入到结果中
                TreeNode node = stack.pop();
                result.add(node.val);
            }
        }
        return result;
    }

    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.4.3后序遍历

package daimasuixiangshuati.day13_erchashu;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * @Author LeiGe
 * @Date 2023/11/2
 * @Description todo
 */
public class ErChaShuDeHouXuBianLi145_TongYiDieDai_3 {
    /**
     * 方法1:后序遍历-统一迭代法:标记法
     *
     * @param root
     * @return
     */
    public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();

        if (root != null) {
            stack.push(root);
        }

        while (!stack.isEmpty()) {
            TreeNode peekNode = stack.peek();

            if (peekNode != null) {
                // 将该节点弹出,避免重复操作,下面将 中右左节点添加到栈中
                stack.pop();

                // 放入中间节点,中间节点访问过,但是还没有处理,加入空节点标记
                stack.push(peekNode);
                stack.push(null);

                // 放入右节点
                if (peekNode.right != null) {
                    stack.push(peekNode.right);
                }

                // 放入左节点
                if (peekNode.left != null) {
                    stack.push(peekNode.left);
                }

            } else {
                // 弹出空节点
                stack.pop();
                // 重新取出栈中元素,加入到结果中
                TreeNode node = stack.pop();
                result.add(node.val);
            }
        }
        return result;
    }

    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;
        }
    }
}

2.刷题

无

3.小结

递归法的前中后序遍历可以写出统一风格的代码,但是迭代法由于中序遍历节点的访问顺序和处理节点顺序不一致,所以中序遍历和前序遍历风格不一致,为了解决这个问题,通过在栈中加入null值做标记,这就是统一迭代法的风格

144. 二叉树的前序遍历 - 力扣（LeetCode）

94. 二叉树的中序遍历 - 力扣（LeetCode）

145. 二叉树的后序遍历 - 力扣（LeetCode）

天上小雷
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C语言实现二叉树遍历的迭代算法
09-04
主要介绍了C语言实现二叉树遍历的迭代算法,包括二叉树的中序遍历、先序遍历及后序遍历等,是非常经典的算法,需要的朋友可以参考下
二叉树的非递归后序遍历算法实例详解
01-19
前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。方法有很多，这里只举一种，先定义栈结点的数据结构 代码如下:typedef struct{...
代码随想录算法训练营Day 14|二叉树Part01|二叉树理论基础、递归遍历 、迭代遍历、统一迭代
m0_51759998的博客
04-03 901
前面介绍的树，都没有数值的，而二叉搜索树是有数值的了，二叉搜索树是一个有序树。下面这两棵树都是搜索树 又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 常用 通过指针把分布在各个地址的节点串联一起。 如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。 递归遍历 二叉树的前序遍历 二叉树的中序遍历 二叉树的后序遍历每次写递归，
代码随想录算法训练营Day14 | 二叉树理论基础、递归遍历、迭代遍历、统一迭代
ckw_lztxdy的博客
02-06 385
int value;
代码随想录算法训练营Day14|二叉树（理论基础、递归遍历、迭代遍历、统一迭代）
qq_41929830的博客
01-09 1090
代码随想录算法训练营Day14|二叉树（理论基础、递归遍历、迭代遍历、统一迭代）
代码随想录算法训练营|DAY14|二叉树|理论基础 、递归遍历、迭代遍历、统一迭代
king12345678k的博客
09-13 54
【代码】代码随想录算法训练营|DAY14|二叉树|理论基础 、递归遍历、迭代遍历、统一迭代。
代码随想录算法训练营Day12 | 二叉树理论基础、递归遍历、迭代遍历、统一迭代
宁愿过拟合不要欠拟合
05-05 2017
二叉树：基础理论、递归遍历、迭代遍历、统一迭代
代码随想录算法训练营 Day 14 | 二叉树理论基础，递归遍历，迭代遍历
MisakaMirai的博客
04-18 121
第一次理解二叉树的遍历。。
代码随想录算法训练营day14 | 二叉树理论基础，递归遍历，迭代遍历，统一迭代法
jzh013的博客
10-06 434
二叉树
代码随想录算法训练营第day14|二叉树理论基础、二叉树递归遍历、二叉树迭代遍历
qq_60513199的博客
03-10 754
写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。最后再说一说二叉树中深度优先和广度优先遍历实现方式，我们做二叉树相关题目，经常会使用递归的方式来实现深度优先遍历，也就是实现前中后序遍历，使用递归是比较方便的。而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。确定每一层递归需要处理的信息。
代码随想录算法训练营Day14|二叉树理论基础及其递归遍历和迭代遍历
m0_68682181的博客
12-29 1087
int val;二叉树的定义和链表类似，只是二叉树的节点多了一个指针，指向左右孩子。本文主要介绍了二叉树的基础和遍历方式，知识点较多，需要多次回顾复习，尤其是二叉树的递归遍历尤其重要，是展开后序题目的基础，通过力扣上三道基础题的练习，要熟练掌握二叉树前中后序的递归遍历和迭代遍历！
遍历二叉树的4个非递归算法.rar_binary tree_二叉树_二叉树 非递归 遍历_递归_遍历 CSharp
09-14
二叉树的4个非递归算法,中序先序后序和层次遍历,算法都有注释而且很详细,适合数据结构学习者使用
二叉树前序遍历的非递归算法
09-04
主要介绍了二叉树前序遍历的非递归算法,需要的朋友可以参考下
二叉树递归与非递归遍历
11-03
二叉树递归与非递归遍历
简单的项目部署脚本（转载）
u010230019的博客
06-09 652
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1446
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 464
修改菜品——后端Java
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
最新发布
lx_nhs的博客
06-12 445
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
先序非递归遍历算法遍历二叉树 ​中序非递归遍历算法遍历二叉树 ​后序非递归遍历算法遍历二叉树 ​层序遍历二叉树
05-09
好的，我可以给您介绍一下二叉树的四种非递归遍历算法以及层序遍历。 先序非递归遍历算法： 1. 新建一个栈，将根节点入栈。 2. 当栈不为空时，取出栈顶元素并访问它。 3. 将当前节点的右子节点（如果存在）入栈，再...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值