代码随想录算法训练营第十一天(二叉树)

最新推荐文章于 2024-09-27 00:32:45 发布
最新推荐文章于 2024-09-27 00:32:45 发布
阅读量43 收藏
点赞数
文章标签： 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fsys1/article/details/133525298
版权

文档讲解：代码随想录二叉树
视频讲解：二叉树 BILIBILI
状态：

二叉树理论基础

二叉树的遍历方式：

  1. 深度优先遍历：先往深走，遇到叶子节点再往回走
  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;
    }
}
二叉树的深度遍历(递归法)

方法：

  • 确定递归函数的参数和返回值
  • 确定终止条件
  • 确定单层递归的逻辑

在二叉树遍历中：

  • 递归函数参数是TreeNode，没有返回值
  • 终止条件是TreeNode对象为null
  • 单层递归逻辑就是确定左右中节点的顺序

LeetCode 144.前序遍历

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

LeetCode 145.二叉树的后序遍历

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

LeetCode 94.二叉树的中序遍历

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        inorder(root, list);
        return list;
    }
    public void inorder(TreeNode root, ArrayList<Integer> list) {
        if(root == null)return;
        inorder(root.left, list);
        list.add(root.val);
        inorder(root.right, list);
    }
}
二叉树的深度遍历(迭代法)

使用栈去书写，但应注意的是，栈是先进后出，故前序遍历加入栈的顺序右左

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        if(root == null)return list;
        deque.push(root);
        while(!deque.isEmpty()) {
            TreeNode node = deque.pop();
            list.add(node.val);
            if(node.right != null)deque.push(node.right);
            if(node.left != null)deque.push(node.left);
        }
        return list;
    }
}

后序遍历实际上就是前序遍历的方法得出结果后反转一下，只是左右节点加入栈的顺序要调换

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        if(root == null)return list;
        deque.push(root);
        while(!deque.isEmpty()) {
            TreeNode node = deque.pop();
            list.add(node.val);
            if(node.left != null)deque.push(node.left);
            if(node.right != null)deque.push(node.right);
        }
        Collections.reverse(list);
        return list;
    }
}

中序遍历相对复杂，前后序遍历实际上是边遍历边操作，而中序遍历是先遍历后操作

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        TreeNode cur = root;
        while(cur != null || !deque.isEmpty()) {
            if(cur != null) {
                deque.push(cur);
                cur = cur.left;
            } else {
                cur = deque.pop();
                list.add(cur.val);
                cur = cur.right;
            }
        }
        return list;
    }
}
二叉树的深度遍历(统一迭代法)

采用标记中间节点的方式，先按顺序加入前中后节点，在中间节点后加null，表示后面的中间节点是要进行操作的。

// 前序遍历
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if(root == null)return list;
        stack.push(root);
        while(!stack.isEmpty()) {
            TreeNode cur = stack.peek();
            if(cur != null) {
                stack.pop();
                if(cur.right != null)stack.push(cur.right);
                if(cur.left != null)stack.push(cur.left);
                stack.push(cur);
                stack.push(null);
            } else {
                stack.pop();
                cur = stack.pop();
                list.add(cur.val);
            }
        }
        return list;
    }
}
// 后序遍历
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if(root == null)return list;
        stack.push(root);
        while(!stack.isEmpty()) {
            TreeNode cur = stack.peek();
            if(cur != null) {
                stack.pop();
                stack.push(cur);
                stack.push(null);
                if(cur.right != null)stack.push(cur.right);
                if(cur.left != null)stack.push(cur.left);
            } else {
                stack.pop();
                cur = stack.pop();
                list.add(cur.val);
            }
        }
        return list;
    }
}

// 中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if(root == null)return list;
        stack.push(root);
        while(!stack.isEmpty()) {
            TreeNode cur = stack.peek();
            if(cur != null) {
                stack.pop();
                if(cur.right != null)stack.push(cur.right);
                stack.push(cur);
                stack.push(null);
                if(cur.left != null)stack.push(cur.left);
            } else {
                stack.pop();
                cur = stack.pop();
                list.add(cur.val);
            }
        }
        return list;
    }
}
二叉树层序遍历

LeetCode 102.二叉树的层序遍历

// 迭代法
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {

        List<List<Integer>> res = new ArrayList<>();
        if(root == null)return res;

        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        deque.add(root);

        while(!deque.isEmpty()) {

            ArrayList<Integer> line = new ArrayList<>();
            int size = deque.size();

            for(int i = 0; i < size; i++) {

                TreeNode t = deque.pop();
                line.add(t.val);

                if(t.left != null)deque.add(t.left);
                if(t.right != null)deque.add(t.right);

            }
            res.add(line);
        }
        return res;
    }
}
// 迭代
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        checkFunc(root, res, 0);
        return res;
    }
    public void checkFunc(TreeNode root, List<List<Integer>> res, int deep) {
        if(root == null)return;
        deep++;
        if(res.size() < deep) {
            ArrayList<Integer> line = new ArrayList<>();
            res.add(line);
        }
        res.get(deep - 1).add(root.val);
        checkFunc(root.left, res, deep);
        checkFunc(root.right, res, deep);
    }
}

LeetCode 107.二叉树层序遍历II

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null)return res;
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        deque.add(root);
        while(!deque.isEmpty()) {
            ArrayList<Integer> line = new ArrayList<>();
            int size = deque.size();
            for(int i = 0; i < size; i++) {
                TreeNode cur = deque.pop();
                line.add(cur.val);
                if(cur.left != null)deque.add(cur.left);
                if(cur.right != null)deque.add(cur.right);
            }
            res.add(line);
        }
        Collections.reverse(res);
        return res;
    }
}

LeetCode 199.二叉树的右视图

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null)return res;
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        deque.add(root);
        while(!deque.isEmpty()) {
            int size = deque.size();
            for(int i = 0; i < size; i++) {
                TreeNode cur = deque.pop();
                if(i == size - 1)res.add(cur.val);
                if(cur.left != null)deque.add(cur.left);
                if(cur.right != null)deque.add(cur.right);
            }
        }
        return res;
    }
}

LeetCode 637.二叉树的层平均值

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new ArrayList<>();
        if(root == null)return res;
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        deque.add(root);
        while(!deque.isEmpty()) {
            int size = deque.size();
            double sum = 0;
            for(int i = 0; i < size; i++) {
                TreeNode cur = deque.pop();
                sum += cur.val;
                if(cur.left != null)deque.add(cur.left);
                if(cur.right != null)deque.add(cur.right);
            }
            res.add(1.00000 * sum / size);
        }
        return res;
    }
}

LeetCode 429.N叉树的层序遍历

 

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null)return res;
        ArrayDeque<Node> deque = new ArrayDeque<>();
        deque.add(root);
        while(!deque.isEmpty()) {
            int size = deque.size();
            ArrayList<Integer> line = new ArrayList<>();
            for(int i = 0; i < size; i++) {
                Node cur = deque.pop();
                line.add(cur.val);
                for(Node node : cur.children) {
                    if(node != null)deque.add(node);
                }
            }
            res.add(line);
        }
        return res;
    }
}

LeetCode 515.在每个树行中找最大值

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null)return res;
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        deque.add(root);
        while(!deque.isEmpty()) {
            int size = deque.size();
            int max = deque.peek().val;
            for(int i = 0; i < size; i++) {
                TreeNode cur = deque.pop();
                if(max < cur.val)max = cur.val;
                if(cur.left != null)deque.add(cur.left);
                if(cur.right != null)deque.add(cur.right);
            }
            res.add(max);
        }
        return res;
    }
}

LeetCode 116.填充每个节点的下一个右侧节点指针

《代码随想录》里是记录前一个节点的方式，我觉得我的方法可能更适合我一点

class Solution {
    public Node connect(Node root) {
        if(root == null)return null;
        ArrayDeque<Node> deque = new ArrayDeque<>();
        deque.add(root);
        while(!deque.isEmpty()) {
            int size = deque.size();
            for(int i = 0; i < size; i++) {
                Node cur = deque.pop();
                cur.next = i == size - 1 ? null: deque.peek();
                if(cur.left != null)deque.add(cur.left);
                if(cur.right != null)deque.add(cur.right);
            }
        }
        return root;
    }
}

LeetCode 117.填充每个节点的下一个右侧节点指针II

class Solution {
    public Node connect(Node root) {
        if(root == null)return null;
        ArrayDeque<Node> deque = new ArrayDeque<>();
        deque.add(root);
        while(!deque.isEmpty()) {
            int size = deque.size();
            for(int i = 0; i < size; i++) {
                Node cur = deque.pop();
                cur.next = i == size - 1 ? null : deque.peek();
                if(cur.left != null)deque.add(cur.left);
                if(cur.right != null)deque.add(cur.right);
            }
        }
        return root;
    }
}

LeetCode 104.二叉树的最大深度

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null)return 0;
        int deep = 0;
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        deque.add(root);
        while(!deque.isEmpty()) {
            int size = deque.size();
            for(int i = 0; i < size; i++) {
                TreeNode cur = deque.pop();
                if(cur.left != null)deque.add(cur.left);
                if(cur.right != null)deque.add(cur.right);
            }
            deep++;
        }
        return deep;
    }
}

LeetCode 111.二叉树的最小深度

class Solution {
    public int minDepth(TreeNode root) {
        if(root == null)return 0;
        int deep = 0;
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        deque.add(root);
        while(!deque.isEmpty()) {
            deep++;
            int size = deque.size();
            for(int i = 0; i < size; i++) {
                TreeNode cur = deque.pop();
                if(cur.left != null) deque.add(cur.left);
                if(cur.right != null)deque.add(cur.right);
                if(cur.left == null && cur.right == null)return deep;
            }
        }
        return deep;
    }
}

碎碎念：今天状态不太行，一整天都是麻了的状态，还好晚上恢复了，才使得今天进度往前走了一小步。

Zephyr_Chaser
关注
代码随想录算法训练营第11天|二叉树part01
zxjiaya的博客
08-18 1291
前中后序遍历，层次遍历，二叉树的详细知识点，还是学的东西很多很杂
代码随想录算法训练营第十三天（二叉树 一）
b1ankwall的博客
08-12 943
参加代码随想录第43期算法训练营day13|二叉树理论基础，144.二叉树的前序遍历，145.二叉树的中序遍历，94.二叉树的后序遍历，层序遍历合集(层序遍历合集共十题)
代码随想录算法训练营第十天 | 二叉树系列1
weixin_45690942的博客
07-06 1741
这里是要会定义：二叉树的节点。(实现方式其实就是链表)
【LeetCode】二叉树的遍历——代码随想录算法训练营Day14
晴雪月乔的博客
01-23 1347
二叉树的前序遍历，中序遍历和后序遍历
代码随想录算法训练营总结篇
dream_aleaf的博客
07-08 1245
总的来说，通过这些天的学习，我觉得收获许多！再到二叉树、回溯算法、贪心算法、动态规划、单调栈，我深刻地体会到了网上流行的一句话，“一根笔，一杯茶，一道leetcode做一天”，有的题自己思考一直都想不到，不妨看一下题解，不仅可以节省时间，还可以减少自己的痛苦，通过学习前辈的方法，看看能否内化。刷题不能只看数量，要看质量，我发现我之前做过的题目，第二次再做时又出现问题了，不能背答案，要自己理解，自己想明白，融会贯通，有的题目真的是换汤不换药，仅仅是应用场景改变，核心代码并没有改变。
代码随想录算法训练营第十五天（二叉树 三）
b1ankwall的博客
08-14 1389
参加代码随想录第43期算法训练营day15|110.平衡二叉树，257. 二叉树的所有路径，404.左叶子之和，222.完全二叉树的节点个数
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 824
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
代码随想录算法训练营第十六天（二叉树 四）
b1ankwall的博客
08-15 1122
参加代码随想录第43期算法训练营day16|513.找树左下角的值，112. 路径总和，106.从中序与后序遍历序列构造二叉树
代码随想录算法训练营完结篇 ★★★
weixin_41725662的博客
09-11 1569
训练营笔记完结篇。
代码随想录算法训练营第十八天（二叉树 六）
b1ankwall的博客
08-17 1351
参加代码随想录第43期算法训练营day18|530.二叉搜索树的最小绝对差，501.二叉搜索树中的众数，236. 二叉树的最近公共祖先
代码随想录算法训练营Day14|二叉树重点理论基础、递归遍历
m0_60979177的博客
12-20 1306
Day14打卡！今日感想：今天开启二叉树篇章！主要学习了递归法的遍历，之前学的有一点“浮于表面”，要注重学习基本逻辑，尽量把问题的根本理解透彻。
代码随想录算法训练营第十七天| ● 110.平衡二叉树 ● 257. 二叉树的所有路径 ● 404.左叶子之和
Zhen_JIANG的博客
04-08 384
● 110.平衡二叉树 ● 257. 二叉树的所有路径 ● 404.左叶子之和
代码随想录算法训练营Day11 | 递归遍历，迭代遍历，统一迭代，层序遍历
little__penguin的博客
06-21 405
代码随想录-035期-算法训练营【博客笔记汇总表】
upward
04-10 615
代码随想录-035期-算法训练营【博客笔记汇总表】
Hello Algorithm：Capture 1，2 初识算法
最新发布
m0_62716099的博客
09-27 577
能力有限，欢迎大家一同交流讨论！
189. 轮转数组（C++）
weixin_45813121的博客
09-25 441
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
Python实现Phong着色模型算法
qq_42568323的博客
09-24 1320
通过本文的介绍，我们详细阐述了Phong着色模型的基本原理，并使用Python实现了相关的算法。通过定义向量、光源、材质和着色器等类，我们可以灵活地计算光照和着色效果，为更复杂的三维图形渲染打下基础。Phong着色模型是计算机图形学中的经典光照模型，尽管随着技术的发展，出现了更复杂的光照模型（如Blinn-Phong、物理基础渲染等），但其简洁明了的特点仍然使其在许多应用中得以广泛使用。希望通过本次学习，读者能够深入理解Phong着色模型，并能够在实际项目中应用该算法。
完全二叉树和堆排序
2301_80412275的博客
09-25 514
在满足第一个条件的前提下，最后一层的节点从左到右填充，没有空隙。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值