代码随想录算法训练营第十一天| 二叉树递归遍历、层序遍历

已于 2024-08-26 17:15:42 修改
阅读量799 收藏 13
点赞数 26
分类专栏： 代码随想录算法训练营 文章标签： 算法 数据结构
于 2024-08-26 17:13:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43831376/article/details/141563778
版权

今日内容

  • 二叉树理论基础
  • 递归遍历
  • 层序遍历

二叉树理论基础

二叉树的类型

做题时常见的二叉树主要有 满二叉树、完全二叉树 和 二叉搜索树。

满二叉树只有度为0和2的节点，且度为0的节点全部在同一层：

深度为 k 的满二叉树总共有 2 ^ k - 1 个节点。

完全二叉树除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。如图所示：

二叉搜索树则是有序且带数值的。二叉搜索树有如下特点：

  1. 若存在左子树，则根节点的值大于左子树上所有节点的值。
  2. 若存在右子树，则根节点的值小于右子树上所有节点的值。
  3. 左右子树也都是二叉搜索树。

二叉搜索树如下图所示： 

在二叉搜索树中还有个平衡二叉搜索树，也被称为AVL（Adelson-Velsky and Landis）树。平衡二叉搜索树要么是空树，要么左右子树的高度绝对值不能大于 1，并且左右子树也是平衡二叉搜索树。如图所示：

二叉树的存储方式

二叉树有两种存储方式：链式存储 和 顺序存储。前者用指针，后者用数组。

链式存储的示意图如下：

顺序存储则是由数组存储，如下图所示：

用顺序存储的话，若父节点的下标为 i ，那么它的左子树为 i * 2 + 1，右子树为 i * 2 + 2 

不过一般来说，链式存储更好理解，顺序存储只需要了解了解就好。

二叉树的遍历方式

二叉树有深度遍历方式和广度遍历方式。

深度遍历：碰到子树就进去，碰到叶子节点后返回。有前序/中序/后序遍历问题（递归法、迭代法）

广度遍历：一层一层遍历。有层序遍历问题（迭代法）

层序遍历很好理解，主要是前中后序遍历容易搞混。前中后序遍历中的“前中后”指的是根节点的顺序，比如前序遍历则说明按照“根左右”顺序遍历，中序遍历则是按照“左根右”顺序。

深度遍历一般用递归方式解决，而递归可以使用栈解决。

广度遍历一般则使用队列解决，因为队列先进先出的特性有助于一层层地遍历。

二叉树的定义

和链表一样，力扣平台默认给出了定义，但是我们还是应该自己手搓一下：

class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(){}
    
    public TreeNode(int val, TreeNode left, TreeNode right){
        this.val = val;
        this.left = left;
        this.right = right;
    }

递归遍历

文章链接：代码随想录 (programmercarl.com)

递归，非常非常非常容易被绕进去，原因就在于写递归前没有按照有效的步骤进行，纯纯按照玄学，这样肯定不行。

一般写递归时，要注意如下三点：

  1. 确定递归函数的参数和返回的值
  2. 设置递归函数的停止条件，以防栈溢出
  3. 确定单层递归的逻辑

下面就以二叉树的前中后序遍历为例。

Leetcode. 144 二叉树的前序遍历

 题目链接：144. 二叉树的前序遍历 - 力扣（LeetCode）

前序遍历的次序为“根左右”，并且要求返回一个列表，列表中的元素以前序遍历次序排布。

  1. 先分析递归函数的参数和返回值。首先我们要操作的是二叉树的节点，所以肯定需要传入节点。再者，题目要求一个列表，所以也需要传入一个列表对其进行操作。因为列表是引用类型，所以不需要递归函数返回东西了。
  2. 再思考递归函数的停止条件。在这个函数中，只有当节点为空时，递归函数才会停下。所以停止条件就是当节点为空时。
  3. 最后确定单层处理逻辑。在进行遍历时，我们要先读取根节点的值，再去读取左右子树的值。这就是单层的处理逻辑。

根据上述的分析，我们就可以写出如下代码：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        preOrder(root, result);
        return result;
    }
    
    public void preOrder(TreeNode root, List<Integer> list){ // 参数和返回值
        if (root == null){return;} // 停止条件
        // 单层逻辑
        list.add(root.val);
        preOrder(root.left, list);
        preOrder(root.right, list);
    }
}

以这种思路，中序和后序遍历无非就是在单层逻辑上进行微调就好。

Leetcode. 94 二叉树的中序遍历

题目链接：94. 二叉树的中序遍历 - 力扣（LeetCode）

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        inOrder(root, result);
        return result;
    }

    public void inOrder(TreeNode root, List<Integer> list){
        if (root == null){return;}
        // 不同之处
        inOrder(root.left, list);
        list.add(root.val);
        inOrder(root.right, list);
    }
}

Leetcode. 145 二叉树的后序遍历

题目链接：145. 二叉树的后序遍历 - 力扣（LeetCode）

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

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

层序遍历

文章链接：代码随想录 (programmercarl.com)

正如之前提到的，层序遍历可以使用队列实现。因为队列先入先出的特性，非常适合一层一层去遍历元素。其原理如下图所示：

根据上述图示，我们可以写出这样一套模板：

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null){return result;}
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        
        while (!queue.isEmpty()){
            int len = queue.size();
            List<Integer> temp = new ArrayList<>(); 
            // 每次 for 循环都表示遍历一层 
            for (int i = 0; i < len; i++){
                TreeNode elem = queue.peek();
                temp.add(elem.val);
                queue.poll();
                if (elem.left != null){queue.offer(elem.left);}
                if (elem.right != null){queue.offer(elem.right);}
            }
            result.add(temp);
        }
        return result;
    }
}

 同样根据上面的思路，可以写出一个递归的模板：

class Solution {
    public static void level(TreeNode n, List<List<Integer>> list, int depth){
        if (n == null){return;}
        if (list.size() == depth){
            List<Integer> temp = new ArrayList<Integer>();
            list.add(temp);    
        }
        list.get(depth).add(n.val);
        level(n.left, list, depth + 1);
        level(n.right, list, depth + 1);
    }

    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null){return result;}
        level(root, result, 0);
        return result;
    }
}

Leetcode. 102 二叉树的层序遍历

题目链接：102. 二叉树的层序遍历 - 力扣（LeetCode）

代码如下：

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null){return result;}
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            //TreeNode n = queue.peek();
            int len = queue.size();
            List<Integer> temp = new ArrayList<>();  
            for (int i = 0; i < len; i++){
                TreeNode elem = queue.peek();
                temp.add(elem.val);
                queue.poll();
                if (elem.left != null){queue.offer(elem.left);}
                if (elem.right != null){queue.offer(elem.right);}
            }
            result.add(temp);
        }
        return result;
    }
}

Leetcode. 107 二叉树的层序遍历Ⅱ

题目链接：107. 二叉树的层序遍历 II - 力扣（LeetCode） 

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null){return result;}
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            List<Integer> temp = new LinkedList<>();
            int len = queue.size();
            for (int i = 0; i < len; i++){
                TreeNode n = queue.peek();
                queue.poll();
                temp.add(n.val);
                if (n.left != null){queue.offer(n.left);}
                if (n.right != null){queue.offer(n.right);}
            }
            result.add(temp);
        }
        // 加个反转
        Collections.reverse(result);
        return result;
    }
}

 Leetcode. 199 二叉树的右视图

题目链接：199. 二叉树的右视图 - 力扣（LeetCode）

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
    /*
        本题特殊之处在于取右视图
        那么基本设想就是找每一层的最后一个元素
    */
        List<Integer> result = new ArrayList<>();
        if (root == null){return result;}
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            int len = queue.size();        
            for (int i = 0; i < len; i++){
                TreeNode n = queue.peek();
                queue.poll();
                if (i == len - 1){result.add(n.val);}
                if (n.left != null){queue.offer(n.left);}
                if (n.right != null){queue.offer(n.right);} 
            }
        }
        return result;
    }
}

 Leetcode. 637 二叉树的层平均值

题目链接：637. 二叉树的层平均值 - 力扣（LeetCode）

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> result = new ArrayList<>();
        if (root == null){return result;}
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            long sum = 0;
            double ave = 0.0;
            int len = queue.size();
            for (int i = 0; i < len; i++){
                TreeNode n = queue.peek();
                queue.poll();
                sum += n.val;
                if (n.left != null){queue.offer(n.left);}
                if (n.right != null){queue.offer(n.right);}
            }
            ave = (double)sum / len;
            result.add(ave);
        }
        return result;
    }
}

 Leetcode. 429 N叉树的层序遍历

题目链接：429. N 叉树的层序遍历 - 力扣（LeetCode）

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null){return result;}
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            List<Integer> temp = new ArrayList<>();
            int len = queue.size();
            Node n;
            for (int i = 0; i < len; i++){
                n = queue.peek();
                queue.poll();
                temp.add(n.val);
                List<Node> nodeTemp = n.children;
                for (int j = 0; j < nodeTemp.size(); j++){
                    queue.offer(nodeTemp.get(j));
                }
            }
            result.add(temp);
        }
        return result;
    }
}

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

题目链接：515. 在每个树行中找最大值 - 力扣（LeetCode） 

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){return result;}
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            int len = queue.size();
            int max = 0;
            for (int i = 0; i < len; i++){
                TreeNode n = queue.peek();
                if (i == 0){
                    max = n.val;
                } else {
                    max = max > n.val ? max : n.val;
                }
                queue.poll();
                if (n.left != null){queue.offer(n.left);}
                if (n.right != null){queue.offer(n.right);}
            }
            result.add(max);
        }
        return result;
    }
}

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

题目链接：116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode） 

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

Leetcode. 117 填充每个节点的下一个右侧节点指针Ⅱ

题目链接：117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode） 

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

 Leetcode. 104 二叉树的最大深度

题目链接：104. 二叉树的最大深度 - 力扣（LeetCode）

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null){return 0;}
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int depth = 0;
        while (!queue.isEmpty()){
            int len = queue.size();
            depth += 1;
            for (int i = 0; i < len; i++){
                TreeNode n = queue.peek();
                queue.poll();
                if (n.left != null){queue.offer(n.left);}
                if (n.right != null){queue.offer(n.right);}
            }   
        }
        return depth;
    }
}

Leetcode. 111 二叉树的最小深度 

题目链接：111. 二叉树的最小深度 - 力扣（LeetCode） 

class Solution {
    public int minDepth(TreeNode root) {
        // 找最先出现叶节点的层
        if (root == null){return 0;}
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int depth = 0;
        while (!queue.isEmpty()){
            int len = queue.size();
            depth += 1;
            for (int i = 0; i < len; i++){
                TreeNode n = queue.peek();
                queue.poll();
                if (n.left == null && n.right == null){
                    return depth;
                } else {
                    if (n.left != null){queue.offer(n.left);}
                    if (n.right != null){queue.offer(n.right);}
                }
            }
        }
        return depth;
    }
}

总结

从未一次做那么多题，就算有模板，套的也很累。

不过对二叉树的理解更加深刻了，其实二叉树之前一直是一知半解，经过了这次刷题，对递归遍历和层序遍历的理解更清晰了一点。

DonciSacer
关注
专栏目录
二叉树前序遍历的非递归算法
09-04
"二叉树前序遍历的非递归算法" 二叉树前序遍历的非递归算法是指在不使用递归函数的情况下，对二叉树进行前序遍历的算法。前序遍历是指先访问根节点，然后访问左子树，最后访问右子树。 在了解非递归算法之前，我们...
二叉树递归与非递归遍历
11-03
递归遍历的优点在于其代码简洁明了，但缺点是当处理大规模的二叉树时，递归可能会导致栈溢出，因为每次递归调用都会增加栈的深度。 **非递归遍历** 1. **前序遍历**： - 使用一个栈来保存待访问的节点。 - 将根...
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
《代码随想录》是一本深受程序员喜爱的编程学习资料，尤其在算法领域，它提供了丰富的实例和深入的解析，帮助读者理解并掌握动态规划、回溯、递归、二叉树以及贪心等核心算法。这些算法是解决复杂计算问题的基础工具...
python3实现二叉树的遍历与递归算法解析(小结)
09-19
在Python3中，二叉树是一种重要的数据结构，它由节点构成，每个节点可以有零个、一个或两个子节点。...递归遍历是实现这些操作的常见手段，而Python3的简洁语法使得实现这些算法变得直观且易于理解。
二叉树系列 10/11
2301_78191305的博客
10-11 249
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 442
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 1292
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
c语言练习题2(字符串和函数的使用)
m0_74859128的博客
10-10 211
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
【三】【算法】P1007 独木桥,P1012 [NOIP1998 提高组] 拼数,P1019 [NOIP2000 提高组] 单词接龙
最新发布
m0_74163972的博客
10-11 396
你希望找些刺激，于是命令你的士兵们到前方的一座独木桥上欣赏风景，而你留在桥下欣赏士兵们。另外，总部也在安排阻拦敌人的进攻，因此你还需要知道你的部队最多需要多少时间才能全部撤离独木桥。单词接龙是一个与我们经常玩的成语接龙相类似的游戏，现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”（每个单词都最多在“龙”中出现两次），在两个单词相连时，其重合部分合为一部分，例如。突然，你收到从指挥部发来的信息，敌军的轰炸机正朝着你所在的独木桥飞来！的数据，满足初始时，没有两个士兵同在一个坐标，
设计算法int IsExistEL(MGraph G)，判断G是否存在EL路径，若存在，则返回1 ，否则返回0。
m0_56332819的博客
10-11 90
设计算法int IsExistEL(MGraph G)，判断G是否存在EL路径，若存在，则返回1 ，否则返回0。C语言
【算法】---归并排序（递归非递归实现）
何春秋的博客
10-03 1191
归并排序 in Java
算法讲解—最小生成树（Kruskal 算法）
ZH_qaq的博客
10-05 1353
根据度娘的解释我们可以知道，最小生成树(Minimum Spanning Tree, MST)就是：一个有n个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有n个结点，并且有保持图连通的最少的边。简单点来说就是求最小的连通图，就是从一个点能到达图的任意一点，且花费的代价最小（所有边的权值最小）。最小生成树问题通常用于网络设计、电路设计等领域，目的是找到连接所有节点的最低成本方式。常见的算法有克鲁斯卡尔算法（Kruskal）和普里姆算法（Prim）等。
C - Separated Lunch
m0_74304371的博客
10-05 480
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
代码随想录算法训练营day50
qq_56445436的博客
10-07 239
【代码】代码随想录算法训练营day50。
16.最接近的三数之和
weixin_61695887的博客
10-04 339
与三数之和的题类似，首先对数组进行排序。排序后的数组使得我们可以有效地使用双指针法来找到和最接近目标值的三元组。：遍历结束后，返回最接近的三元组的和。，然后通过双指针法来寻找另外两个数。：遍历排序后的数组，固定一个数。中选出三个整数，使它们的和与。假定每组输入只存在恰好一个解。使得三数之和最接近目标值。
python-FILIP/字符串p形编码/数字三角形
2401_83954530的博客
10-04 965
例如：字符串 122344111 可被描述为 1个1、2个2、1个3、2个4、3个1 ，因此我们说122344111 的 p 型编码串为 1122132431；100200300 可描述为 1个1、2个 0、1个2、2个0、1个3、2个0，因此它的 p 型编码串为 112012201320。对于 100% 的数据，100≤a,b≤999，a,b 不含 0 或不为 0。那么该数的翻转同样有 f 位，最高位为为 af​，第二位为 af−1​，……设原数有 f 位，最高位为 a1​，第二位为 a2​，。
算法训练营打卡Day18
Zoe_igxgx的博客
09-29 977
示例 2: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出: 5 解释: 节点 5 和节点 4 的最近公共祖先是节点 5。示例 1: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出: 3 解释: 节点 5 和节点 1 的最近公共祖先是节点 3。例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
第二十一章 （动态内存管理）
code_whiter的博客
10-03 1257
1、栈区：在执行函数的时候，函数内的局部变量的储存单元都可以在栈上创建，函数执行结束的时候这些储存单元自动被释放。当是情况2 的时候，原有空间之后没有⾜够多的空间时，扩展的⽅法是：在堆空间上另找⼀个合适⼤⼩的连续空间来使⽤。c 语言还提供了另一个函数free，是专门用来做动态内存的释放和回收的（一般是要与malloc函数同时使用的），函数原型如下。3.返回类型的是void * ，所以malloc函数并不知道开辟空间的类型，具体在使用者使用的时候自己来选择。2. 数组在申明的时候，必须指定数组的长度，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

DonciSacer

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

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

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

打赏作者

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

抵扣说明：

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

余额充值