day09

最新推荐文章于 2023-03-29 15:47:32 发布
最新推荐文章于 2023-03-29 15:47:32 发布
阅读量893 收藏 1
点赞数
分类专栏： leetcode 文章标签： leetcode 二叉树 算法 深度优先遍历 广度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sj15814963053/article/details/123362583
版权

day09

144. 二叉树的前序遍历

力扣题目链接

题目

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

示例 1：

Untitled

输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

Untitled

输入：root = [1,2]
输出：[1,2]

示例 5：

Untitled

输入：root = [1,null,2]
输出：[1,2]

提示：

树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

递归解法

/**
 * https://leetcode-cn.com/problems/binary-tree-preorder-traversal/
 *
 * @author xiexu
 * @create 2022-03-08 11:29 AM
 */
public class _144_二叉树的前序遍历 {

    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        preorder(root, list);
        return list;
    }

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

}

迭代解法

思路

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

为什么要先加入 右孩子，再加入左孩子呢？ 因为这样出栈的时候才是中左右的顺序。

https://tva1.sinaimg.cn/large/008eGmZEly1gnbmss7603g30eq0d4b2a.gif

代码实现

/**
 * https://leetcode-cn.com/problems/binary-tree-preorder-traversal/
 *
 * @author xiexu
 * @create 2022-03-08 11:40 AM
 */
public class _144_二叉树的前序遍历_迭代法 {

    // 前序遍历顺序：中-左-右，入栈顺序：中-右-左
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            list.add(node.val);
            if (node.right != null) {
                stack.push(node.right);
            }
            if (node.left != null) {
                stack.push(node.left);
            }
        }
        return list;
    }

}

94. 二叉树的中序遍历

力扣题目链接

题目

给定一个二叉树的根节点 root，返回它的 中序遍历。

示例 1：

Untitled

输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

Untitled

输入：root = [1,2]
输出：[2,1]

示例 5：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IOrq1ky3-1646742872124)(day09%20f8681/Untitled%205.png)]

输入：root = [1,null,2]
输出：[1,2]

提示：

树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

递归解法

/**
 * https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
 *
 * @author xiexu
 * @create 2022-03-08 11:37 AM
 */
public class _94_二叉树的中序遍历 {

    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        inorder(root, list);
        return list;
    }

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

}

迭代解法

思路

https://tva1.sinaimg.cn/large/008eGmZEly1gnbmuj244bg30eq0d4kjm.gif

代码实现

/**
 * https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
 *
 * @author xiexu
 * @create 2022-03-08 11:48 AM
 */
public class _94_二叉树的中序遍历_迭代法 {

    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        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();
                list.add(cur.val);
                cur = cur.right;
            }
        }
        return list;
    }

}

145. 二叉树的后序遍历

力扣题目链接

题目

给你一棵二叉树的根节点 root，返回其节点值的 后序遍历 。

示例 1：

Untitled

输入：root = [1,null,2,3]
输出：[3,2,1]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

递归解法

/**
 * https://leetcode-cn.com/problems/binary-tree-postorder-traversal/
 *
 * @author xiexu
 * @create 2022-03-08 11:34 AM
 */
public class _145_二叉树的后序遍历 {

    public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        postorder(root, list);
        return list;
    }

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

}

迭代解法

思路

先序遍历是中左右，后续遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了，如下图：

Untitled

代码实现

/**
 * https://leetcode-cn.com/problems/binary-tree-postorder-traversal/
 *
 * @author xiexu
 * @create 2022-03-08 11:54 AM
 */
public class _145_二叉树的后序遍历_迭代法 {

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

}

102. 二叉树的层序遍历

力扣题目链接

题目

给你二叉树的根节点 root，返回其节点值的 层序遍历。 （即逐层地，从左到右访问所有节点）。

示例 1：

Untitled

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

思路

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。

需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。

使用队列实现二叉树广度优先遍历，动画如下：

https://tva1.sinaimg.cn/large/008eGmZEly1gnad5itmk8g30iw0cqe83.gif

代码实现

/**
 * https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
 *
 * @author xiexu
 * @create 2022-03-08 7:22 PM
 */
public class _102_二叉树的层序遍历 {

    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if (root != null) {
            queue.offer(root);
        }
        // 从上到下遍历二叉树的每一层
        while (!queue.isEmpty()) {
            int n = queue.size();
            ArrayList<Integer> list = new ArrayList<>();
            // 从左到右遍历每一层的每个节点
            for (int i = 0; i < n; i++) {
                TreeNode node = queue.poll();
                list.add(node.val);
                // 将下一层节点放入队列
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            res.add(list);
        }
        return res;
    }

}

107. 二叉树的层序遍历 II

力扣题目链接

题目

给你二叉树的根节点 root，返回其节点值 自底向上的层序遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：

Untitled

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

思路

相对于102.二叉树的层序遍历，就是最后把res数组反转一下就可以了。

代码实现

/**
 * https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii/
 *
 * @author xiexu
 * @create 2022-03-08 7:31 PM
 */
public class _107_二叉树的层序遍历_II {

    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if (root != null) {
            queue.offer(root);
        }
        while (!queue.isEmpty()) {
            int n = queue.size();
            ArrayList<Integer> list = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                TreeNode node = queue.poll();
                list.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            res.add(list);
        }
        // 反转二层集合的操作
        List<List<Integer>> result = new ArrayList<>();
        for (int i = res.size() - 1; i >= 0; i--) {
            result.add(res.get(i));
        }
        return result;
    }

}

199. 二叉树的右视图

力扣题目链接

题目

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

Untitled

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

提示:

二叉树的节点个数的范围是 [0,100]
-100 <= Node.val <= 100

思路

层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进res数组中，随后返回res就可以了。

代码实现

/**
 * https://leetcode-cn.com/problems/binary-tree-right-side-view/
 *
 * @author xiexu
 * @create 2022-03-08 7:47 PM
 */
public class _199_二叉树的右视图 {

    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if (root != null) {
            queue.offer(root);
        }
        while (!queue.isEmpty()) {
            int n = queue.size();
            for (int i = 0; i < n; i++) {
                TreeNode node = queue.poll();
                if (i == n - 1) {
                    res.add(node.val);
                }
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        return res;
    }

}

637. 二叉树的层平均值

力扣题目链接

题目

给定一个非空二叉树的根节点 root, 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5以内的答案可以被接受。

示例 1：

Untitled

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。

示例 2:

Untitled

输入：root = [3,9,20,15,7]
输出：[3.00000,14.50000,11.00000]

提示：

树中节点数量在 [1, 104] 范围内
-2^31 <= Node.val <= 2^31 - 1

思路

本题就是层序遍历的时候把每一层求个总和再取一个均值。

代码实现

/**
 * https://leetcode-cn.com/problems/average-of-levels-in-binary-tree/
 *
 * @author xiexu
 * @create 2022-03-08 8:01 PM
 */
public class _637_二叉树的层平均值 {

    public List<Double> averageOfLevels(TreeNode root) {
        ArrayList<Double> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if (root != null) {
            queue.offer(root);
        }
        while (!queue.isEmpty()) {
            int n = queue.size();
            double sum = 0; // 统计每一层的和
            for (int i = 0; i < n; i++) {
                TreeNode node = queue.poll();
                sum += node.val;
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            res.add(sum / n); // 将每一层的平均值放进结果集
        }
        return res;
    }

}

429. N 叉树的层序遍历

力扣题目链接

题目

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例 1：

Untitled

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

示例 2：

img

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

提示：

树的高度不会超过 1000
树的节点总数在 [0, 10^4] 之间

代码实现

/**
 * https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/
 *
 * @author xiexu
 * @create 2022-03-08 8:13 PM
 */
public class _429_N叉树的层序遍历 {

    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new ArrayList<>();
        Queue<Node> queue = new LinkedList<>();
        if (root != null) {
            queue.offer(root);
        }
        while (!queue.isEmpty()) {
            int n = queue.size();
            ArrayList<Integer> list = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                Node node = queue.poll();
                list.add(node.val);
                List<Node> children = node.children;
                if (children == null || children.size() == 0) {
                    continue;
                }
                // 将节点孩子加入队列
                for (Node child : children) {
                    if (child != null) {
                        queue.offer(child);
                    }
                }
            }
            res.add(list);
        }
        return res;
    }

}
猿小羽
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Day09
03-20
Day09
Day09实习日记1
08-08
Java 实训 Day09 实习日记1 今天是 2017 年 7 月 12 日星期三，晴天，地点在工科楼 A203，老师是张明星，单位是南京华信智源教育科技有限公司。本次实习日记主要记录了使用 Java 进行的 MVC 相关操作，并使用 ...
【LeetCode】-- 144. 二叉树的前序遍历
局部变量和全局变量
08-14 522
给你二叉树的根节点root，返回它节点值的前序遍历。
144. 二叉树的前序遍历（中等题）
闭关修炼
12-21 175
题目描述： 给定一个二叉树，返回它的 前序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,2,3] 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/binary-tree-preorder-traversal 著作权归领扣网络所有。商业转载请联系官方授权，非商业转...
leetcode--144--二叉树的前序遍历
__Miracle__
04-13 594
给你二叉树的根节点 root ，返回它节点值的 前序 遍历。 #include <iostream> #include <vector> using namespace std; /// 144. Binary Tree Preorder Traversal /// https://leetcode.com/problems/binary-tree-preorder-traversal/description/ /// 二叉树的前序遍历 /// 时间复杂度: O(n), n
代码随想录算法训练营day15| LeetCode 102 二叉树的层序遍历 、LeetCode 107 二叉树的层序遍历 II、LeetCode 199 二叉树的右视图
qq_51588716的博客
02-16 87
代码随想录算法训练营day15
【662. 二叉树最大宽度】
Sugar_wolf的博客
08-27 379
一个编号为 index 的左子节点的编号记为 2 × index，右子节点的编号记为 2 × index + 1，计算每层宽度时，用每层节点的最大编号减去最小编号再加 1 即为宽度。遍历时如果是先访问左子节点，再访问右子节点，每一层最先访问到的节点会是最左边的节点，即每一层编号的最小值，需要记录下来进行后续的比较。一次深度优先搜索中，需要当前节点到当前行最左边节点的宽度，以及对子节点进行深度优先搜索，求出最大宽度，并返回最大宽度。遍历节点时，可以用广度优先搜索来遍历每一层的节点，并求出最大值。...
day09.md
04-12
day09.md
二叉树前序遍历Java
wenjinjie1的博客
11-19 849
二叉树的前序遍历 给你二叉树的根节点 root ，返回它节点值的 前序 遍历。 示例 1： 输入：root = [1,null,2,3] 输出：[1,2,3] 示例 2： 输入：root = [] 输出：[] 示例 3： 输入：root = [1] 输出：[1] 示例 4： 输入：root = [1,2] 输出：[1,2] 示例 5： 输入：root = [1,null,2] 输出：[1,2] 方法：迭代 思路： 建立一个ArrayList数组进行储存元素顺序 声明一个栈，按照根左右的顺序数组先a
【蓝桥Java每日一练】————6.二叉树的前中后序遍历（递归与迭代）
执梗的博客
01-11 1万+
二叉树的前后中序遍历，如何理解真正的递归思想？如何写出迭代的方法？如何在面试中写出更好的遍历？
树--二叉树的前序遍历
RXY24601的博客
10-12 365
如果采用定义一个全局变量i，当只有一个结点的时候会出现内存越界。因为在多个测试用例的前提下，PrevOrder函数会被重复多次调用，全局变量i会记录每一次调用的累加值，必须要在每一次调用之前将全局函数i置零，才能保证每一次记录的i都是从0开始的。在PrevOrder函数实现的过程中，由于是函数递归，所以为了利用i来给数组a赋值，每个函数内都有一个i，必须要用指针*i记录才能完成。所以下面这种实现方式在单个用例的测试中无问题，但多次测试就会报错。
LeetCode（Python）—— 二叉树的后序遍历（简单）
热门推荐
m0_61661179的博客
10-19 5万+
概述：给你一棵二叉树的根节点 root ，返回其节点值的后序遍历 。
用java实现二叉树的后序遍历（递归和迭代）
m0_57248752的博客
03-29 1808
用java实现二叉树的后序遍历（递归和迭代两种方法），有详细注释以及图解
leetcode144. 二叉树的前序遍历
zhang_han666的博客
12-15 188
题目： 给你二叉树的根节点 root ，返回它节点值的 前序 遍历。 示例： 思路：递归 代码： # Definition for a binary tree node. # class TreeNode(object): # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right cla
【算法leetcode每日一练】层数最深叶子节点的和
二当家的白帽子
05-04 643
给你一棵二叉树的根节点 root ，请你返回 层数最深的叶子节点的和 。
学会二叉树不知道干啥?二叉树的深度优先搜索和广度优先搜索,我要打十个乃至二十个(打开你的LeetCode撸起来)学练并举
小杰312的博客
03-04 1805
学会二叉树不知道干啥?二叉树的深度优先搜索和广度优先搜索,我要打十个乃至二十个
JavaScript算法19- 二叉树的层序遍历（leetCode:102）
Y_soybean_milk的博客
05-02 1015
二叉树的层序遍历 一、题目 给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。 示例 输入：root = [3,9,20,null,null,15,7] 输出：[[3],[9,20],[15,7]] 二、题解 层序遍历就是广度优先遍历 不过在遍历的时候需要记录当前节点所处的层级，方便将其添加到不同的数组中 /** * Definition for a binary tree node. * function TreeNode(val, left,
二叉树递归类题目
weixin_42127177的博客
02-24 798
题目 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。 方法：分别用递归、BFS、DFS /** * 递归方式遍历反转 */ public TreeNode invertTree(TreeNode root) { if (root == null) { return null; } TreeNode temp = root.left; root.left = root.
【查找】验证二叉排序树，给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉排序树。（java）
m0_67463447的博客
03-29 2532
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉排序树。 有效 二叉排序树定义如下： 节点的左子树只包含 小于 当前节点的数。 节点的右子树只包含 大于 当前节点的数。 所有左子树和右子树自身必须也是二叉排序树。 树中节点数目范围在[1, 104] 内 −231<= Node.val <= 231 - 1 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/validate-binary-search-tree 函数接口
Invalid bound statement (not found): com.demo.day09_mybatis.mapper.EmpMapper.list
最新发布
09-11
Invalid bound statement (not found): com.demo.day09_mybatis.mapper.EmpMapper.list是一个错误信息，通常出现在使用Mybatis时。这个错误信息表明在EmpMapper接口中的list方法对应的SQL语句没有在mapper.xml文件中...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猿小羽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值