力扣之每日四题day01--二叉树遍历篇

二叉树遍历

144.二叉树的前序遍历

力扣地址

java 复制代码
import java.util.ArrayList;
import java.util.List;

/**
 * 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 {
    public List<Integer> preorderTraversal(TreeNode root) {
        //方法用于初始化并返回前序遍历的结果列表
        List<Integer>res=new ArrayList<>();
        //调用递归的前序遍历方法
        preorderTraversal(root,res);
        return res;
    }
    //递归方法用于前序遍历
    public void preorderTraversal(TreeNode root, List<Integer>res){
        //基本情况,如果当前节点为空,返回
        if(root==null){
            return;
        }
        //将当前节点的值加入到结果列表
        res.add(root.val);
        //递归调用左子树
        preorderTraversal(root.left,res);
        //递归调用右子树
        preorderTraversal(root.right,res);
    }
}

二叉树的前序遍历是一种深度优先遍历(DFS)的方法,它按照"根节点 -> 左子树 -> 右子树"的顺序遍历二叉树的节点。具体实现思路如下:

  • 基本情况:首先处理基本情况,即当前节点为空时直接返回,表示到达了二叉树的叶子节点或空节点。
  • 处理当前节点:对于非空节点,将当前节点的值添加到结果列表中,表示对当前节点的访问。
  • 递归遍历左子树:然后递归调用前序遍历方法,传入当前节点的左子树作为新的根节点,继续遍历左子树的节点。
  • 递归遍历右子树:最后递归调用前序遍历方法,传入当前节点的右子树作为新的根节点,继续遍历右子树的节点。

145.二叉树的后序遍历

力扣地址

java 复制代码
import java.util.ArrayList;
import java.util.List;

/**
 * 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 {
    public List<Integer> postorderTraversal(TreeNode root) {
        //创建一个存储结果结果的列表
        List<Integer>res=new ArrayList<Integer>();
        //递归调用方法
        postorderTraversal(root,res);
        //返回遍历的结果
        return res;
        

    }
    //定义递归方法,实现二叉树的后序遍历
    public void postorderTraversal(TreeNode root,List<Integer>res){
        //如果当前节点返回为空
        if(root==null){
            return;
        }
        //遍历左子树
        postorderTraversal(root.left,res);
        //遍历右子树
        postorderTraversal(root.right,res);
        //将当前节点的值添加到遍历结果列表
        res.add(root.val);
    }
}

二叉树的后序遍历是一种深度优先遍历(DFS)的方法,它按照"左子树 -> 右子树 -> 根节点"的顺序遍历二叉树的节点。具体实现思路如下:

  • 基本情况:首先处理基本情况,即当前节点为空时直接返回,表示到达了二叉树的叶子节点或空节点。
  • 递归遍历左子树:然后递归调用后序遍历方法,传入当前节点的左子树作为新的根节点,继续遍历左子树的节点。
  • 递归遍历右子树:接着递归调用后序遍历方法,传入当前节点的右子树作为新的根节点,继续遍历右子树的节点。
  • 处理当前节点:最后,将当前节点的值添加到结果列表中,表示对当前节点的访问。

94.二叉树的中序遍历

java 复制代码
import java.util.ArrayList;
import java.util.List;

/**
 * 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 {
    public List<Integer> inorderTraversal(TreeNode root) {
        //创建一个存储遍历结果的列表
        List<Integer>res=new ArrayList<>();
        //调用递归方法进行中序遍历
        inorder(root,res);
        //返回值
        return res;

    }
    //定义递归的方法,实现二叉树的中序遍历
    public void inorder(TreeNode root,List<Integer>res){
        //如果当前节点为空,直接返回
        if(root==null){
            return;
        }
        //遍历左子树
        inorder(root.left,res);
        //将当前节点的值添加到res列表中
        res.add(root.val);
        //遍历右子树
        inorder(root.right, res);
    }

}

二叉树的中序遍历是一种深度优先遍历(DFS)的方法,它按照"左子树 -> 根节点 -> 右子树"的顺序遍历二叉树的节点。具体实现思路如下

  • 基本情况:首先处理基本情况,即当前节点为空时直接返回,表示到达了二叉树的叶子节点或空节点。
  • 递归遍历左子树:然后递归调用中序遍历方法,传入当前节点的左子树作为新的根节点,继续遍历左子树的节点。
  • 处理当前节点:接着将当前节点的值添加到结果列表中,表示对当前节点的访问。
  • 递归遍历右子树:最后递归调用中序遍历方法,传入当前节点的右子树作为新的根节点,继续遍历右子树的节点。

102.二叉树的层序遍历

力扣地址

java 复制代码
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;

/**
 * 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 {
    //方法用途:按照层序遍历二叉树,将每一层的节点值存储在列表中,返回所有层的列表
    public List<List<Integer>> levelOrder(TreeNode root) {
        //存储最终的结果列表
        List<List<Integer>>res=new ArrayList<>();
        //用队列进行层序遍历
        Queue<TreeNode>queue=new ArrayDeque<>();
        //如果根节点不为空,将根节点加入队列
        if(root!=null){
            queue.add(root);
        }
        //循环遍历每一层的节点
        while(!queue.isEmpty()){
            //获取当前层的节点的个数
            int n=queue.size();
            //用于存储当前层节点的值
            List<Integer>level=new ArrayList<>();
            //遍历当前的节点
            for(int i=0;i<n;i++){
                //出队列,获取当前的节点
                TreeNode node=queue.poll();
                //将当前节点加入当前层的列表
                level.add(node.val);
                //将当前节点的左孩子加入队列
                if(node.left!=null){
                    queue.add(node.left);
                }
                //将当前节点的右孩子加入队列
                if(node.right!=null){
                    queue.add(node.right);
                }
            }
            //将当前层的列表加入最终结果列表
            res.add(level);
        }
        //返回最终结果列表
        return res;


    }
}

二叉树的层序遍历是一种广度优先遍历(BFS)的方法,它按照层级顺序逐层遍历二叉树的节点。具体思路如下

  • 创建数据结构:首先定义一个队列 queue 用于存储待遍历的节点,以及一个结果列表 res 用于存储每一层的节点值。
  • 初始化:如果根节点不为空,则将根节点加入队列。
  • 层序遍历:使用循环遍历每一层的节点,直到队列为空。在循环中
  • 获取当前层的节点个数 n,这个值等于当前队列的大小,表示当前层的节点数。
  • 创建一个列表 level 用于存储当前层的节点值。
  • 遍历当前层的节点,从队列中依次取出节点,将节点值加入 level 列表中,然后将节点的左右子节点(如果存在)加入队列。
  • 将存储当前层节点值的 level 列表加入结果列表 res 中。
相关推荐
Blossom.11818 分钟前
量子计算在密码学中的应用与挑战:重塑信息安全的未来
人工智能·深度学习·物联网·算法·密码学·量子计算·量子安全
1白天的黑夜123 分钟前
贪心算法-860.柠檬水找零-力扣(LeetCode)
c++·算法·leetcode·贪心算法
搏博31 分钟前
专家系统的基本概念解析——基于《人工智能原理与方法》的深度拓展
人工智能·python·深度学习·算法·机器学习·概率论
yzx99101331 分钟前
决策树随机深林
人工智能·python·算法·决策树·机器学习
Y1nhl1 小时前
力扣hot100_子串_python版本
开发语言·python·算法·leetcode·职场和发展
uhakadotcom1 小时前
过来人给1-3 年技术新人的几点小小的建议,帮助你提升职场竞争力
算法·面试·架构
wuqingshun3141592 小时前
蓝桥杯 16. 密文搜索
c++·算法·职场和发展·蓝桥杯·深度优先
Brookty2 小时前
【数据结构】哈希表
数据结构·算法·哈希算法·散列表
Dovis(誓平步青云)3 小时前
【数据结构】·励志大厂版(复习+刷题):二叉树
c语言·数据结构·经验分享·笔记·学习·算法·学习方法
越城3 小时前
算法效率的钥匙:从大O看复杂度计算 —— C语言数据结构第一讲
c语言·开发语言·数据结构·算法