[力扣]二叉树1—基础+遍历

已于 2022-05-10 20:32:04 修改
阅读量819 收藏
点赞数
分类专栏： 力扣刷题 文章标签： leetcode b树 数据结构
于 2022-04-28 21:35:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51699336/article/details/124448997
版权
  • 讲解二叉树基础部分
  • 深度优先(遍历+迭代都要掌握)及广度优先的代码实现

代码随想录[原文指路]

概述

1.种类

  • 满二叉树：二叉树只有度(子节点个数)为0与2的节点，且度为0的节点在同一层
    在这里插入图片描述
  • 完全二叉树：底层以上全被填满，底层节点从左向右连续(集中于左边)
    在这里插入图片描述
  • 二叉搜索树(二叉排序树)
    在这里插入图片描述
满二叉树与完全二叉树没有数值的概念，而二叉搜索树有
1.若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值
2.若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值
3.它的左、右子树也分别为二叉排序树
  • 平衡二叉搜索树(AVL)：空树或左右两子树高度差绝对值不超过1，并且是平衡二叉树
    在这里插入图片描述
  • 堆是完全二叉树和排序的结合，而不是平衡二叉搜索树
堆是一棵完全二叉树(一定是平衡二叉树)，同时保证父子节点的顺序关系(父节点大于子节点)
而搜索树是父节点大于左孩子，小于右孩子，所以堆不是平衡二叉搜索树

2.存储方式

  • 链式存储(链表)
    在这里插入图片描述
  • 顺序存储(数组)
    在这里插入图片描述

3.遍历方式

  • 深度优先(先往深处再往回)
1.前序遍历：中左右
2.中序遍历：左中右
3.后序遍历：左右中
  • 广度优先(层层向下)
层次遍历(迭代，队列)
  • morris遍历(此处不介绍)

深度优先遍历

1.递归三步走

  • 确定递归函数参数和返回值
确定哪些参数是递归的过程中需要处理的进而确定递归函数的参数
确定每次递归的返回值是什么进而确定递归函数的返回类型
	-->相当于确定函数的作用
  • 确定终止条件
  • 确定单层递归逻辑
确定每层递归需要处理的信息，清晰重复调用自己实现递归的过程
  • 实际项目开发中要尽量避免递归！

2.二叉树的前序遍历[144]

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

    public void preorder(TreeNode root,List<Integer> res){
        if(root==null) return;
        res.add(root.val);
        preorder(root.left,res);
        preorder(root.right,res);
    }
}
  • 迭代
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Stack<TreeNode> st = new Stack<>();
        if(root!=null)st.push(root);
        //注意空节点不入栈
        while(!st.isEmpty()){
            TreeNode node = st.peek();
            if(node!=null){
                st.pop();//将当前节点弹出避免重复操作
                if(node.right!=null) st.push(node.right);//添加右节点
                if(node.left!=null) st.push(node.left);//添加左节点
                st.push(node);//添加中间节点
                st.push(null);//中节点访问过，但是还没有处理，加入空节点做为标记
            } else {//遇到空节点时将下一个节点放进结果集
                st.pop();//将空节点弹出
                node = st.peek();//取出空节点的下一个节点
                st.pop();//出栈
                result.add(node.val);//加入结果集
            }
        }
        return result;
    }
}
  • 迭代
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        while(root!=null||!stack.isEmpty()){
            while(root!=null){
                list.add(root.val);
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            root = root.right;
        }
        return list;
    }
}

3.二叉树的中序遍历[94]

  • 递归
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorder(root,res);
        return res;
    }

    public void inorder(TreeNode root,List<Integer> res){
        if(root==null) return;
        inorder(root.left,res);
        res.add(root.val);
        inorder(root.right,res);
    }
}
  • 迭代
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Stack<TreeNode> st = new Stack<>();
        if(root!=null)st.push(root);
        //注意空节点不入栈
        while(!st.empty()){
            TreeNode node = st.peek();
            if(node!=null){
                st.pop();//将当前节点弹出避免重复操作
                if(node.right!=null) st.push(node.right);//添加右节点
                st.push(node);//添加中间节点
                st.push(null);//中节点访问过，但是还没有处理，加入空节点做为标记
                if(node.left!=null) st.push(node.left);//添加左节点
            } else {//遇到空节点时将下一个节点放进结果集
                st.pop();//将空节点弹出
                node = st.peek();//取出空节点的下一个节点
                st.pop();//出栈
                result.add(node.val);//加入结果集
            }
        }
        return result;
    }
}
  • 迭代
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        while(root!=null||!stack.isEmpty()){
            while(root!=null){
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            list.add(root.val);
            root = root.right;
        }
        return list;
    }
}

4.二叉树的后序遍历[145]

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

    public void postorder(TreeNode root,List<Integer> res){
        if(root==null) return;
        postorder(root.left,res);
        postorder(root.right,res);
        res.add(root.val);
    }
}
  • 迭代
class Solution {
    public List<Integer> postorderTraversal(TreeNode root){
        List<Integer> result = new LinkedList<>();
        Stack<TreeNode> st = new Stack<>();
        if(root!=null)st.push(root);
        //注意空节点不入栈
        while(!st.empty()){
            TreeNode node = st.peek();
            if(node!=null){
                st.pop();//将当前节点弹出避免重复操作
                st.push(node);//添加中间节点
                st.push(null);//中节点访问过，但是还没有处理，加入空节点做为标记
                if(node.right!=null) st.push(node.right);//添加右节点
                if(node.left!=null) st.push(node.left);//添加左节点
            } else {//遇到空节点时将下一个节点放进结果集
                st.pop();//将空节点弹出
                node = st.peek();//取出空节点的下一个节点
                st.pop();//出栈
                result.add(node.val);//加入结果集
            }
        }
        return result;
    }
}

5.N 叉树的前序遍历[589]

class Solution {
    public List<Integer> preorder(Node root) {
        List<Integer> res = new ArrayList();
        pre(root,res);
        return res;
    }

    public void pre(Node root,List<Integer> res) {
        if(root==null) return;

        res.add(root.val);
        for(Node node:root.children){
            pre(node,res);
        }
    }
}

6.N 叉树的后序遍历[590]

class Solution {
    public List<Integer> postorder(Node root) {
        List<Integer> res = new ArrayList();
        post(root,res);
        return res;
    }

    public void post(Node root,List<Integer> res) {
        if(root==null) return;

        for(Node node:root.children){
            post(node,res);
        }
        res.add(root.val);
    }
}

广度优先遍历

  • 每个题都是1基础上改进

1.二叉树的层序遍历[102]

  • 迭代
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ress = new ArrayList();
        List<Integer> res;
        if(root==null) return ress;

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

2.二叉树的层序遍历 II[107]

  • 在前一题基础上反转结果，此处借助堆，便于反转
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> ress = new ArrayList();
        Stack<List<Integer>> stack = new Stack();
        List<Integer> res;
        if(root==null) return ress;

        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            res = new ArrayList();
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                res.add(node.val);
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
            stack.push(res);
        }
       
        while(!stack.isEmpty()) ress.add(stack.pop());
        return ress;
    }
}

3.二叉树的右视图[199]

  • 取每层最后节点保存
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        //并不是简单的输出所有右子树的右子树...
        //层序遍历，每一层取最后节点保存
        List<Integer> res = new ArrayList();
        if(root==null) return res;

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

4.二叉树的层平均值[637]

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> ress = new ArrayList();
        if(root==null) return ress;

        double res;
        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            res = 0.0;
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                res += node.val;
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
            ress.add(res/size);
        }
        return ress;
    }
}

5.N 叉树的层序遍历[429]

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> ress = new ArrayList();
        List<Integer> res;
        if(root==null) return ress;

        Queue<Node> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            res = new ArrayList();
            int size = queue.size();
            for(int i=0;i<size;i++){
                Node node = queue.poll();
                res.add(node.val);
                if(node.children!=null){
                    for(Node no:node.children){
                        queue.offer(no);
                    }
                }
            }
            ress.add(res);
        }
        return ress;
    }
}

6.在每个树行中找最大值[515]

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList();
        if(root==null) return res;
        
        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int max=Integer.MIN_VALUE;
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                max = Math.max(max,node.val);
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
            res.add(max);
        }
        return res;
    }
}

7.填充每个节点的下一个右侧节点指针[116]

class Solution {
    public Node connect(Node root) {
        if(root==null) return root;

        Queue<Node> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i=0;i<size;i++){
                Node node = queue.poll();
                if(i<size-1) node.next = queue.peek();
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
        }
        return root;
    }
}

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

  • 解同上题

9.二叉树的最大深度[104]

  • 层数就是最大深度
class Solution {
    public int maxDepth(TreeNode root) {
        int res = 0;
        if(root==null) return res;

        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
            res++;
        }
        return res;
    }
}

10.二叉树的最小深度[111]

  • 左右子节点都为空时满足最小深度
class Solution {
    public int minDepth(TreeNode root) {
        int res = 0;
        if(root==null) return res;

        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            res++;
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
                if(node.left==null&&node.right==null){
                    return res;
                }
            }
        }
        return res;
    }
}

总结

1.递归与迭代的优劣

  • 不考虑函数调用开销和函数调用产生的堆栈开销，二者的时间复杂度差不多
  • 空间复杂度递归开销更大
  • 递归方便程序员，但难为机器，实际开发中避免使用递归！
ChenJieYaYa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[力扣]144. 二叉树的前序遍历java
12-21
二叉树遍历是针对二叉树进行操作的一种基本算法，主要有三种类型：前序遍历、中序遍历和后序遍历。本问题主要关注的是前序遍历，它是二叉树遍历的一种常见方式。 **前序遍历**的顺序是：先访问根节点，然后递归地...
leetcode-CPP:力扣刷题C ++篇
03-27
leetcode刷题笔记 从3.20起，太简单的就不记录了 数据结构 1.链表 160.链表相交 206.反转链表 92.反转链表2 2....105.从前序和中序遍历建造二叉树 二叉树的深度 一体二叉树 8.斐波那契 跳台阶问题
力扣：二叉树的中序遍历
K_CRACKING的博客
08-03 272
给定一个二叉树，返回它的中序 遍历。 示例： 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,3,2] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ 代码： /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(i
力扣：二叉树的遍历java
qq_42325147的博客
10-21 300
力扣：二叉树的遍历java
力扣——二叉树的中序遍历
weixin_74485957的博客
11-12 181
二叉树的中序遍历
力扣刷题之二叉树的层序遍历
m0_58367586的博客
04-12 2162
二叉树的层序遍历
力扣：二叉树的层序遍历
DoMoreSpeakLess的博客
04-06 119
102. 二叉树的层序遍历 给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。 示例 1： 输入：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 /** * Defi
js代码-二叉树前序遍历
07-16
**前序遍历** 是二叉树遍历的一种方法，其顺序为：访问根节点 -> 遍历左子树 -> 遍历右子树。这个顺序可以递归地应用到每个子树上，确保每个节点按照规定的顺序被访问。 在JavaScript中实现二叉树的前序遍历通常有...
力扣刷题 | 二叉树
12-20
文章目录总述基本概念二叉树性质二叉树遍历94 二叉树的中序遍历95 不同的二叉搜索树296 不同的二叉搜索树98 验证二叉搜索树100 相同的树101 对称二叉树102 二叉树的层序遍历103 二叉树的锯齿形层次遍历104 二叉树的...
Java实现 LeetCode 637 二叉树的层平均值（遍历树）
12-21
这个问题主要考察了对二叉树的层次遍历（Level Order Traversal）的理解与实现。 首先，我们需要定义一个二叉树节点的类`TreeNode`，包含节点值`val`、左子节点`left`和右子节点`right`： ```java public class ...
stack(leetcode练习题,牛客)
2301_81692739的博客
07-19 428
最开始写的，总会有一些样例过不了，没考虑全，后来看题解上的方法，将下标压入栈中，用右括号的下标减去栈顶下标，就是有效长度。不然只顾着最长，反而无法得到正确的有效长度。一个完整的括号，要么是1，要么里边包含其他括号，进行了 *2。所以，可以每遇到一个右括号，进行一次运算，第一次为 1，以后每次乘二，累加到栈顶。遇到左括号，就向栈压入0，重新运算，当遇到右括号，再弹出.如果数字比栈顶小就压入，否则，将栈顶删除直到，比栈顶小或这栈为空。关于stack的知识，可以看点击查看上面的博客，以下题目全在。
Java | Leetcode Java题解之第273题整数转换英文表示
m0_57195758的博客
07-22 266
Java | Leetcode Java题解之第273题整数转换英文表示
【LeetCode】分隔链表
qq_26521261的博客
07-20 412
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
LeetCode 188题： 买卖股票的最佳时机IV优化（原创）
it_fly的专栏
07-21 250
算法思路：1.买了j次的最大获利值等于：昨天买了j次，和昨天卖了j-1次，今天再买的最大值；2.卖了j次的最大获利值等于：昨天卖了j次，和昨天买了j次，今天再卖掉的最大值
【LeetCode】80.删除有序数组中的重复项II
说文科技，做有态度的研究。
07-21 193
思路很好想到，但是实现起来不是那么容易。
leetcode4 -- 寻找两个正序数组的中位数
m0_65985318的博客
07-23 129
先将两数组合并，然后利用sort排序算法，对数组进行从小到大的排序，根据总长度是奇数或者偶数来决定中位数的位置。合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5。合并数组 = [1,2,3] ，中位数 2。请你找出并返回这两个正序数组的。的正序（从小到大）数组。算法的时间复杂度应该为。
leetcode 69. x 的平方根
m0_49013185的博客
07-24 101
可以使用二分查找法或牛顿迭代法来实现 LeetCode 问题。下面是使用二分查找法和牛顿迭代法的 C++ 实现。
(leetcode学习)110. 平衡二叉树
最新发布
m0_54888411的博客
07-24 197
很久没写结构体了，复习一下。学习二叉树的通用解题方法。给定一个二叉树，判断它是否是。
leetcode-104. 二叉树的最大深度
曼巴的博客
07-23 264
3）再逐渐往回返，每个当前层的长度为左右子树长度的较大值+1。是指从根节点到最远叶子节点的最长路径上的节点数。2）遍历到底部（叶子结点）时，当前层的长度为1。4）如果当前没节点，返回0。1）递归地从上向下走。
二叉树的层序遍历力扣
08-17
二叉树的层序遍历是一种广度优先搜索算法，通过逐层地从左到右访问所有节点，返回节点值的顺序。可以使用队列来实现层序遍历。具体思路如下： 1. 创建一个空的结果数组res和一个队列que，将根节点root放入队列que中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值