代码随想录 刷题记录-7 二叉树（1）基本概念及操作篇

于 2024-08-14 23:30:00 发布
阅读量896 收藏 29
点赞数 23
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Renas_TJOvO/article/details/141101882
版权

一、理论基础

1.二叉树的种类

满二叉树

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

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

完全二叉树

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

二叉搜索树

二叉搜索树的结点带数值，是一棵有序树，满足：

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

平衡二叉搜索树

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

对于平衡二叉搜索树，增删的操作时间是logn

Java里TreeSet、TreeMap的底层实现是平衡二叉搜索树

2.二叉树的存储方式

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

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

3.二叉树的遍历方式

二叉树主要有两种遍历方式：

  1. 深度优先遍历：先往深走，遇到叶子节点再往回走。
  2. 广度优先遍历：一层一层的去遍历。
  • 深度优先遍历
    • 前序遍历（递归法，迭代法）
    • 中序遍历（递归法，迭代法）
    • 后序遍历（递归法，迭代法）
  • 广度优先遍历
    • 层次遍历（迭代法）

深度优先搜索使用栈、递归实现方便；

广度优先搜索使用队列实现方便。

4.二叉树的定义

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.二叉树的递归遍历

每次写递归，都按照这三要素来写，可以保证写出正确的递归算法

  1. 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。

  2. 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

  3. 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

// 前序遍历·递归·LC144_二叉树的前序遍历
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        preorder(root, result);
        return result;
    }

    public void preorder(TreeNode root, List<Integer> result) {
        if (root == null) {
            return;
        }
        result.add(root.val);
        preorder(root.left, result);
        preorder(root.right, result);
    }
}
// 中序遍历·递归·LC94_二叉树的中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        inorder(root, res);
        return res;
    }

    void inorder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        inorder(root.left, list);
        list.add(root.val);             // 注意这一句
        inorder(root.right, list);
    }
}
// 后序遍历·递归·LC145_二叉树的后序遍历
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        postorder(root, res);
        return res;
    }

    void postorder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        postorder(root.left, list);
        postorder(root.right, list);
        list.add(root.val);             // 注意这一句
    }
}

2.二叉树的迭代遍历

前序遍历：先处理根节点，然后右孩子入栈，然后左孩子入栈

中序遍历：在前序遍历中，要访问的元素和要处理的元素顺序是一致的，都是中间节点，易于书写代码。

        中序遍历的顺序是左中右，访问的顺序和处理的顺序是不一致的，需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。

后序遍历：

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

所以后序遍历只需要前序遍历的代码稍作修改就可以了

// 前序遍历顺序：中-左-右，入栈顺序：中-右-左
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> inorderTraversal(TreeNode root) {
        List<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{
               cur = stack.pop();
               result.add(cur.val);
               cur = cur.right;
           }
        }
        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;
    }
}

3.二叉树的统一迭代

针对三种遍历方式，使用迭代法是可以写出统一风格的代码

以中序遍历为例，使用栈的话，无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况。

那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。

如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。 这种方法也可以叫做标记法

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> preorderTraversal(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);  // 添加右节点（空节点不入栈）
                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> 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;
   }
}

4.二叉树层序遍历

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> levelOrder(TreeNode root) {
       level(root);
       return res;

    }

    public void level(TreeNode root){
        if(root == null) return;
        Deque<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> item = new ArrayList<>();
            int len = queue.size();
            for(int i = 0; i < len ;i++){
                TreeNode tmp = queue.remove();
                item.add(tmp.val);
                if(tmp.left!=null) queue.add(tmp.left);
                if(tmp.right!=null) queue.add(tmp.right);
            }
            res.add(item);
        }
    }
}

层序遍历相关题目

107.二叉树的层次遍历 II

只需要最后翻转一下结果

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> levelOrder(TreeNode root) {
       level(root);
       return res;

    }

    public void level(TreeNode root){
        if(root == null) return;
        Deque<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> item = new ArrayList<>();
            int len = queue.size();
            for(int i = 0; i < len ;i++){
                TreeNode tmp = queue.remove();
                item.add(tmp.val);
                if(tmp.left!=null) queue.add(tmp.left);
                if(tmp.right!=null) queue.add(tmp.right);
            }
            res.add(item);
        }
    }
}

199.二叉树的右视图

思路

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

class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> rightSideView(TreeNode root) {
       level(root);
       return res;

    }

    public void level(TreeNode root){
        if(root == null) return;
        Deque<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int len = queue.size();
            for(int i = 0; i < len ;i++){
                TreeNode tmp = queue.remove();
                if(tmp.left!=null) queue.add(tmp.left);
                if(tmp.right!=null) queue.add(tmp.right);
                if(i==len-1) res.add(tmp.val);
            }

        }
    }
}

429.N叉树的层序遍历

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/
class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> levelOrder(Node root) {
        level(root);
        return res;

    }

    public void level(Node root){
        if(root == null) return;
        Deque<Node> queue = new ArrayDeque<>();
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> item = new ArrayList<>();
            int len = queue.size();
            for(int i = 0 ;i<len ;i++){
                Node tmp = queue.remove();
                item.add(tmp.val);
                List<Node> children = tmp.children;
                if(children==null || children.size()==0){
                    continue;
                }
                for(Node child :children){
                    if(child!=null) queue.add(child);
                }
            }
            res.add(item);
        }
    }
}

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

本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了。

Renas_TJOvO
关注
  • 23
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
《代码随想录》是一本深受程序员喜爱的编程学习资料，尤其在算法领域，它提供了丰富的实例和深入的解析，帮助读者理解并掌握动态规划、回溯、递归、二叉树以及贪心等核心算法。这些算法是解决复杂计算问题的基础工具...
二叉树的基本操作是什么-以及学习二叉树的基本操作有什么用
04-24
二叉树的基本操作实现
二叉树理论基础篇
夏沫の梦的博客
11-13 1249
二叉树理论基础篇 说到二叉树，大家对于二叉树其实都很熟悉了，本文呢我也不想教科书式的把二叉树的基础内容在啰嗦一遍，所以一下我讲的都是一些比较重点的内容。 相信只要耐心看完，都会有所收获。 ## 二叉树的种类 在我们解题过程中二叉树有两种主要的形 说到二叉树，大家对于二叉树其实都很熟悉了，本文呢我也不想教科书式的把二叉树的基础内容在啰嗦一遍，所以一下我讲的都是一些比较重点的内容。 相信只要耐心看完，都会有所收获。 ## 二叉树的种类 在我们解题过程中二叉树有两种主要的形式：满二叉树和完全二叉树。
代码随想录No14 |LeetCode 二叉树理论基础1.递归遍历2.迭代遍历3.统一迭代
Rocket,Qian的博客
01-10 307
二叉树的理论基础和深度优先搜索遍历
代码随想录刷题笔记（个人记录使用，不作参考）
清风的博客
01-11 602
1.10从二叉树开始。
代码随想录刷题记录：二叉树篇（第一部分）
qq_53324833的博客
02-06 1219
前言 哈哈哈，到二叉树啦！冲冲冲！！！ 因为好久没看二叉树了，就先复习一下吧（下图全部来自代码随想录）。 对二叉树几个类型概念的简单介绍： 满二叉树 完全二叉树 二叉搜索树 平衡二叉搜索树（即AVL树） 对二叉树的两种存储形式进行简单介绍： 链式存储 顺序存储 用链式表示的二叉树，更有利于我们理解，所以一般我们都是用链式存储二叉树。 144. 二叉树的前序遍历（递归和迭代两种方式） 题目描述 递归方法思路分析： 很简单了，二叉树基础题目。 递归方式代码如下： /** * Definition
代码随想录刷题笔记
Twoton的博客
07-12 602
代码随想录对应题目链接 数组是有序数组，是使用二分查找的基础条件。 以后大家只要看到面试题里给出的数组是有序数组，都可以想一想是否可以使用二分法。或者说可以转换在一个有序数组中找一个数的题目。 同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的。代码随想录对应题目链接 双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。 对于使用双指针的题目，需要明确双指针的含义，针对其含义去思考题解方式。 双指针法（快慢指针法）在数组和链
代码随想录刷题学习笔记——初级篇C++/Python
never_stop_rain的博客
07-29 579
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。来源：力扣（LeetCode）时间复杂度要求—>二分法查找返回两个坐标位置—>二分法分别查找左右边界分析返回的状态：1) [-1,-1]；
力扣java刷题学习（代码随想录学习）2
weixin_44215785的博客
04-20 481
【代码】力扣java刷题学习（代码随想录学习）2。
代码随想录1刷—二叉树篇（二）
h0327x的博客
07-05 1778
如果是模拟前中后序遍历就用栈，如果是适合层序遍历就用队列；其他情况：先用队列试试行不行，不行就用栈。遍历+记录遍历的节点数量就可以了。 利用完全二叉树性质的求法 完全二叉树只有两种情况，情况一：就是满二叉树，情况二：最后一层叶子节点没有满。对于情况一，可以直接用 2^树深度 - 1 来计算，注意这里根节点深度为1。对于情况二，分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1来计算。完全二叉树（一）如图：完全二叉树（二）如图：可以看出如果整个树不是满二叉树，
代码随想录 二叉树模块小结（1）
weixin_52620153的博客
11-26 362
刷题笔记
二叉树-基于C语言实现的二叉树基本操作.zip
04-26
本压缩包包含的是基于C语言实现的二叉树基本操作，是学习和理解二叉树概念以及其实现的一个宝贵资源。 在C语言中，实现二叉树通常涉及定义一个结构体来表示节点，这个结构体至少包含两个指针，分别指向左右子节点，...
javalruleetcode-Leetcode:Leetcode的刷题记录-Java实现
06-29
在Java中，LeetCode的题目涵盖了数据结构、算法、设计模式等多个方面，通过实际编写代码来解决这些问题，可以深入理解这些概念。例如，"LRU缓存机制"是LeetCode中的一道经典题目，它涉及到链表和哈希表的操作。LRU...
我在代码随想录-写代码Day16之二叉树
01-24
二叉树遍历
高阶数据结构——B树
weixin_74310945的博客
08-08 1220
B树：有序数组+平衡多叉树；B+树：有序数组链表+平衡多叉树；B*树：一棵更丰满的，空间利用率更高的B+树。单论树的高度，查找效率来看B树系列确实不错，但是也存在一些缺点。1.空间利用率低，占用的空间大。2.插入和删除数据时，需要进行分裂，涉及到数据的挪动，效率低。3.虽然比起红黑树等，高度更低，但是在内存中都是一个量级的，搜索效率并不比红黑树快多少（在内存中没什么优势）
数据结构之Map和Set（下）
最新发布
我要学编程的博客
08-09 1203
冲突-解决-闭散列、开散列/哈希桶 手动实现哈希表 哈希表和Java类的关系 有关Map和Set的相关练习：只出现一次的数字、随机链表的复制、宝石与石头、前k个高频单词
树和二叉树
2401_83720143的博客
08-08 525
2、如果对一颗有n个结点的完全二叉树（深度为 | log以2为底n的对数 | +1 ）的结点。1、在二叉树的第i层上至多有2的 i-1次方个结点（i>=1），至少有i个结点。1、具有n个结点的完全二叉树的深度为 ： | log以2为底n的对数 | +1。2、深度为k的二叉树至多有2的k次方减1个结点（k>=1），至少有k个结点。2、如果2i>n,则结点i为叶子结点，无左孩子，否则其左孩子是结点 2i。3、如果2i+1>n，则结点 i无右孩子，否则其右孩子是结点 2i+1。根结点：非空树中无前驱结点的结点。
常见8种数据结构
qq_43575301的博客
08-08 2200
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例。该代码使用了递归法的前序遍历，对于每一个节点，交换其左右子节点，然后递归地对其左右子树进行翻转。 引用中给出了一个实现二叉树的层序遍历的代码示例。该代码使用了BFS的思想，借助队列来实现层序遍历。每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列，同时将当前层的节点值添加到结果列表中。 综上所述，参考这些引用，可以通过BFS来实现二叉树的层序遍历，并通过递归法或迭代法来翻转二叉树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值