【二叉树】|代码随想录算法训练营第11天|二叉树递归遍历、二叉树迭代遍历、二叉树层序遍历

于 2024-07-17 10:10:08 发布
阅读量502 收藏 5
点赞数 18
分类专栏： 数据结构与算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CrazySunSky/article/details/140486899
版权

刷题神器

代码随想录

往期回顾

>【栈与队列】|代码随想录算法训练营第10天|150. 逆波兰表达式求值、239. 滑动窗口最大值、347.前 K 个高频元素、【总结】

题目

二叉树理论基础

文章：文章讲解
视频：视频讲解

二叉树种类

  • 满二叉树

    除最底层叶子节点，其余所有的节点都有左右子节点

    深度为k，有2^k-1个节点的二叉树

  • 完全二叉树

    最后一层子节点，从左到右连续的，如果有不连续的就不是完全二叉树

  • 二叉搜索树

    二叉搜索树是一个有序树，如果左子树不空，左子树所有的值都小于根节点的值，如果右子树不空，右子树所有的节点都大于根节点，左右子树也是二叉排序树

  • 平衡二叉搜索树

    左右子树的高度绝对值不超过1， 并且左右子树也是平衡二叉树

二叉树的存储方式

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

链式存储是通过链表左右子针的方式存储的

顺序存储，用的数组方式存储的，如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。

二叉树的遍历方式
  • 深度优先遍历
    • 前序遍历（递归，迭代法） 中 左 右
    • 中序遍历（递归，迭代法） 左 中 右
    • 后续遍历（递归，迭代法） 左 右 中
  • 广度优先遍历
    • 层次遍历（迭代法）
二叉树的定义
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.后序遍历
文章：文章讲解
视频：视频讲解

  • 学后思路

    递归三要素 ：1.确定递归函数的参数和返回值 2.确定终止条件 3.确定单层递归的逻辑

    确定循环的顺序

解法:

// 前序遍历 中 左 右
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList();
        preOrder(result, root);
        return result;
    }

    public void preOrder(List<Integer> result, TreeNode root) {
        if (root == null) {
            return;
        }
        result.add(root.val);
        preOrder(result, root.left);
        preOrder(result, root.right);
    }
}

// 后序遍历 左 右 中
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList();
        postOrder(result, root);
        return result;
    }

    public void postOrder(List<Integer> result, TreeNode root) {
        if (root == null) {
            return;
        }
        postOrder(result, root.left);
        postOrder(result, root.right);
        result.add(root.val);
    }
}

// 中序遍历 左 中 右
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList();
        inOrder(result, root);
        return result;
    }

    public void inOrder(List<Integer> result, TreeNode root) {
        if (root == null) {
            return;
        }
        inOrder(result, root.left);
        result.add(root.val);
        inOrder(result, root.right);
    }
}
  • 题目总结
    • 二叉树的遍历，注意前中后的排序，注意判断条件，什么时候跳出

二叉树的迭代遍历

题目：1.前序遍历

​ 2.中序遍历

​ 3.后序遍历
文章：文章讲解
视频：视频讲解-前后

​ 视频讲解-中

  • 学后思路
    迭代遍历主要是使用栈来实现遍历，前序遍历和后序遍历只需要做反转逻辑，中序遍历需要使用指针

解法一:

// 前序遍历 中 左 右 
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;
    }
}

// 后续遍历 左右中
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;
    }
}

// 中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList();
        Stack<TreeNode> stack = new Stack();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()) {
            // 处理左指针
            if (cur != null) {
                stack.push(cur);
                cur = cur.left;
            } else {
                // 当左指针为null的时候
                cur = stack.pop();
                result.add(cur.val);
                // 判断右节点
                cur = cur.right;
            }
        }
        return result;
    }
}
  • 题目总结
    • 使用迭代遍历，前序和后序要相对简单，前序最简单，后续需要再前序的基础上进行反转
    • 中序遍历需要配合指针只用，注意判断条件，什么时候弹出，什么时候进栈

二叉树的统一迭代法

题目：题目链接
文章：文章讲解
视频：无

  • 学后思路
    使用填充空节点的方法来统一三种迭代方法

解法一:

暂时不处理

题目总结

  • 主要注意如何补充空节点，这样就是为了补充统一格式

二叉树层序遍历登场

文章：文章讲解
视频：视频讲解

  • 学后思路
    层序遍历，广度优先搜索，借用队列
102.二叉树的层序遍历

题目：题目链接

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        Queue<TreeNode> deque = new LinkedList<>();
        if (root == null)
            return result;
        deque.add(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            List<Integer> rs = new ArrayList<>();
            while (size > 0) {
                TreeNode pop = deque.poll();
                rs.add(pop.val);
                if (pop.left != null)
                    deque.add(pop.left);
                if (pop.right != null)
                    deque.add(pop.right);
                size--;
            }
            result.add(rs);
        }
        return result;
    }
}

题目总结

  • 注意队列的size判断，注意进队出队
107. 二叉树的层序遍历 II

题目：题目链接

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        Queue<TreeNode> deque = new LinkedList<>();
        if (root == null)
            return result;
        deque.add(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            List<Integer> rs = new ArrayList<>();
            while (size > 0) {
                TreeNode pop = deque.poll();
                rs.add(pop.val);
                if (pop.left != null)
                    deque.add(pop.left);
                if (pop.right != null)
                    deque.add(pop.right);
                size--;
            }
            result.add(rs);
        }
        Collections.reverse(result);
        return result;
    }
}

题目总结

  • 从下至上遍历，只需要将正序遍历的结果反转即可
199.二叉树的右视图

题目：题目链接

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> rs = new ArrayList<>();
        Queue<TreeNode> deque = new LinkedList<>();
        if (root == null)
            return rs;
        deque.add(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            while (size > 0) {
                TreeNode pop = deque.poll();
                if (size == 1) {
                    rs.add(pop.val);
                }
                if (pop.left != null)
                    deque.add(pop.left);
                if (pop.right != null)
                    deque.add(pop.right);
                size--;
            }
        }
        return rs;
    }
}

题目总结

  • 从右侧看，只保存最右侧节点， 所以要判断每一层的最后一个节点加入到结果集
637. 二叉树的层平均值

题目：题目链接

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> result = new ArrayList<>();
        Queue<TreeNode> deque = new LinkedList<>();
        if (root == null)
            return result;
        deque.add(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            List<Integer> rs = new ArrayList<>();
            while (size > 0) {
                TreeNode pop = deque.poll();
                rs.add(pop.val);
                if (pop.left != null)
                    deque.add(pop.left);
                if (pop.right != null)
                    deque.add(pop.right);
                size--;
            }
            // 注意这个位置的类型转换
            Long rowTotal = rs.stream().mapToLong(r -> Long.valueOf(r)).reduce(Long::sum).getAsLong();
            Double ave = rowTotal / Double.valueOf(rs.size());
            result.add(ave);
        }
        return result;
    }
}

题目总结

  • 这道题的重点是关注除法，每一行的和可能超过int的最大值，所以要用long，size要转换成double
429. N 叉树的层序遍历

题目：题目链接

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> result = new ArrayList<>();
        Queue<Node> deque = new LinkedList<>();
        if (root == null)
            return result;
        deque.add(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            List<Integer> rs = new ArrayList<>();
            while (size > 0) {
                Node pop = deque.poll();
                rs.add(pop.val);
                // 注意节点没有左右子树，是多子树
                if (pop.children != null) {
                    for (Node no : pop.children) {
                        deque.add(no);
                    }
                }
                size--;
            }
            result.add(rs);
        }
        return result;
    }
}

题目总结

  • 注意节点，不在分左右子树，有多子节点，所以处理子节点的时候要遍历处理，不是判断左右子树
515. 在每个树行中找最大值

题目：题目链接

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Queue<TreeNode> deque = new LinkedList<>();
        if (root == null)
            return result;
        deque.add(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            List<Integer> rs = new ArrayList<>();
            while (size > 0) {
                TreeNode pop = deque.poll();
                rs.add(pop.val);
                if (pop.left != null)
                    deque.add(pop.left);
                if (pop.right != null)
                    deque.add(pop.right);
                size--;
            }
            Integer max = rs.stream().max(Comparator.comparing(Integer::intValue)).get();
            result.add(max);
        }
        return result;
    }
}

题目总结

  • 取每一层的最大值，可以全部存起来再判断最大值，也可以再遍历的过程中判断最大值
116. 填充每个节点的下一个右侧节点指针

题目：题目链接

class Solution {
    public Node connect(Node root) {
        if (root == null)
            return root;
        Queue<Node> deque = new LinkedList<>();

        deque.add(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            //List<Node> rs = new ArrayList<>();
            while (size > 0) {
                Node pop = deque.poll();
                // rs.add(pop);
                if(size > 1){
                    pop.next = deque.peek();
                }
                if (pop.left != null)
                    deque.add(pop.left);
                if (pop.right != null)
                    deque.add(pop.right);
                size--;
            }
            //if (rs.size() == 1)
            //    continue;
            //int slow = 0;
            //int fast = 1;
            //while (fast < rs.size()) {
            //    rs.get(slow).next = rs.get(fast);
            //    slow++;
            //    fast++;
            //}
        }
        return root;
    }
}

题目总结

  • 这个题目有两种做法，在弹出每一个的时候判断是不是最后一个，如果不是最后一个可以当前队列的第一个付给next，也可以全部存在一个list中，然后用快慢指针赋值next
117. 填充每个节点的下一个右侧节点指针 II

题目：题目链接

class Solution {
    public Node connect(Node root) {
        if (root == null)
            return root;
        Queue<Node> deque = new LinkedList<>();

        deque.add(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            //List<Node> rs = new ArrayList<>();
            while (size > 0) {
                Node pop = deque.poll();
                // rs.add(pop);
                if(size > 1){
                    pop.next = deque.peek();
                }
                if (pop.left != null)
                    deque.add(pop.left);
                if (pop.right != null)
                    deque.add(pop.right);
                size--;
            }
            //if (rs.size() == 1)
            //    continue;
            //int slow = 0;
            //int fast = 1;
            //while (fast < rs.size()) {
            //    rs.get(slow).next = rs.get(fast);
            //    slow++;
            //    fast++;
            //}
        }
        return root;
    }
}

题目总结

  • 结题思路与116类似，代码一样
104. 二叉树的最大深度

题目：题目链接

class Solution {
    public int maxDepth(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        Queue<TreeNode> deque = new LinkedList<>();
        if (root == null)
            return result.size();
        deque.add(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            List<Integer> rs = new ArrayList<>();
            while (size > 0) {
                TreeNode pop = deque.poll();
                rs.add(pop.val);
                if (pop.left != null)
                    deque.add(pop.left);
                if (pop.right != null)
                    deque.add(pop.right);
                size--;
            }
            result.add(rs);
        }
        return result.size();
    }
}

题目总结

  • 取最大深度，换个思路就是取有多少层，我们把结果收集起来以后，list的长度就是层数，当然也可以不用记录list，直接在循环结束的时候计数也可以
111. 二叉树的最小深度

题目：题目链接

class Solution {
    public int minDepth(TreeNode root) {
        if (root == null)
            return 0;
        Queue<TreeNode> deque = new LinkedList<>();
        int depth = 1;
        deque.add(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            while (size > 0) {
                TreeNode pop = deque.poll();
                // 判断最短路径
                if (pop.left == null && pop.right == null) {
                    return depth;
                }
                if (pop.left != null)
                    deque.add(pop.left);
                if (pop.right != null)
                    deque.add(pop.right);
                size--;
            }
            depth++;
        }
        return 0;
    }
}

题目总结

  • 最小深度，可以同等为从左往右看，第一个没有子节点的高度值，从左往右，当遇到第一个左孩子和右孩子都不存在的节点，那当前节点高度就是最小高度
toolhow
关注
  • 18
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现的二叉树常用操作【前序建树，前中后递归非递归遍历及层序遍历】
08-28
层序遍历是一种树遍历算法，在遍历过程中，我们首先遍历树的第一层，然后遍历第二层，以此类推。下面是使用队列实现层序遍历的Java代码： ```java public static void levelOrder(Node root) { if (root == null) ...
二叉树前序遍历的非递归算法
09-04
"二叉树前序遍历的非递归算法" 二叉树前序遍历的非递归算法是指在不使用递归函数的情况下，对二叉树进行前序遍历的算法。前序遍历是指先访问根节点，然后访问左子树，最后访问右子树。 在了解非递归算法之前，我们...
代码随想录算法训练营第十一天 | 二叉树递归遍历、迭代遍历、层序遍历
weixin_45660657的博客
06-19 427
【代码】代码随想录算法训练营第十一天 | 二叉树递归遍历、迭代遍历、层序遍历。
代码随想录算法训练营第十四天|二叉树递归遍历 二叉树迭代遍历
weixin_74976519的博客
05-02 1444
思路：使用迭代法写中序遍历，需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。思路：将访问的结点放入栈中，把要处理的结点也放入栈中，紧接着放入一个空结点作为标记。思路：先处理中间结点，即根节点先入栈，右孩子入栈，再左孩子入栈。思路：在先序遍历的基础上做些调整，再将结果反转就是答案。
代码随想录算法训练营第十三天 二叉树的遍历（递归，迭代，层序）
2301_79647020的博客
07-15 926
二叉树的遍历遍历本质上是将链表存放的二叉树转换成数组存放的 （1）顺序前序：中左右中序：左中右后续：左右中 （2）深度优先与广度优先 1）深度优先：先尽可能向下遍历，在遍历过程中将节点放入栈，再按照一定顺序将元素放入数组，顺序包括前序、中序、后序用一维数组保存结果 2）广度优先：层序遍历每一层进行遍历，将每一层从左向右先后放进队列，每次取出队首，将队首放入结果内层数组，将队首的左子结点先入队，队首的右子节点后入队。处理完一层以后，内层数组放入结果二维数组。
代码随想录算法训练营第十四天｜二叉树的递归遍历、迭代遍历、层序遍历
2301_79315307的博客
11-07 396
二叉树的递归遍历：题目链接/文章讲解/视频讲解：二叉树的迭代遍历：题目链接/文章讲解/视频讲解：二叉树的层序遍历：
代码随想录算法训练营第14天|二叉树基础、二叉树递归遍历、二叉树迭代遍历
weixin_43753439的博客
04-17 161
回忆了一下二叉搜索树的概念和特点。
C语言实现二叉树遍历的迭代算法
09-04
以上就是C语言实现二叉树遍历的迭代算法，通过这种方式，我们可以高效地遍历二叉树，而无需像递归那样增加调用栈的压力。这对于处理大规模数据或者深度很大的二叉树特别有用。在实际编程中，理解并掌握这些算法对...
matlab实现二叉树遍历算法（源代码）
04-30
本文介绍了在MATLAB中实现二叉树算法的基本步骤。首先，定义了一个名为TreeNode的结构体，用于存储二叉树节点的数据以及指向左右子节点的引用。接着，实现了几个函数来操作这个二叉树，包括insertNode用于插入新节点...
二叉树的非递归后序遍历算法实例详解
01-19
前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。方法有很多，这里只举一种，先定义栈结点的数据结构 代码如下:typedef struct{...
函数模板与类模板
程序员_小兵
07-12 1559
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
基于Big-Bang-Big-Crunch(BBBC)算法的目标函数最小值计算matlab仿真
熟悉python,matlab,C,C++,JAVA等
07-12 381
BBBC算法的核心思想模拟了宇宙从大爆炸（Big Bang）开始，经历扩张，再到可能的大收缩（Big Crunch）的过程，以此类比于在解空间中从初始分散的解集出发，通过一系列搜索过程逐步集中并接近最优解的过程。：一个简化的聚集方法可以是xi′′​=xbest​+β⋅(xi′​−xbest​)，其中xbest​是最优解，β是一个小于1的收缩因子，控制收缩速度。：每个解xi​依据一定的规则在解空间中移动，这个移动可以是随机的，也可以基于某种策略，比如基于目标函数梯度的方向或者利用当前解与其他解的相对位置。
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 371
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
常见的排序算法，复杂度
m0_61544805的博客
07-16 352
稳定 / 非稳定排序：两个相等的数 排序前后 相对位置不变。 插入排序（希尔排序）： 每一趟将一个待排序记录，按其关键字的大小插入到已排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。稳定，O(n)，O(1)。 把记录按下标增量（模）分组，对每组进行直接插入排序，每次排序后减小增量，当增量减至 1 时排序完毕。不稳定，不知道（有个实验结论），O(1)。 冒泡排序： 比较相邻的元素，如果第一个比第二个大就进行交换，对每一对相邻元素做同样的工作。稳定，O(n)，O(1)。 选择
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 782
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
树与二叉树
2201_76027754的博客
07-15 456
树和二叉树
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
hanmo22357的博客
07-12 816
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。
拆分整数 java
最新发布
laocooon的博客
07-16 214
输入: n = 10输出: 36解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。输入: n = 2输出: 1解释: 2 = 1 + 1, 1 × 1 = 1。），并使这些整数的乘积最大化。你可以获得的最大乘积。
N叉树的前序遍历
2301_80805258的博客
07-15 283
Problem: 589. N 叉树的前序遍历 文章目录思路解题过程Code 思路 前序遍历，遇到空节点返回 解题过程 对每个节点进行遍历 Code /* // Definition for a Node. class Node { public: int val; vector<Node*> children; Node() {} Node(int _val) { val = _val; } Node(int _

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值