力扣144、94、145-java刷题笔记

最新推荐文章于 2025-05-09 14:48:06 发布

富江！

最新推荐文章于 2025-05-09 14:48:06 发布

阅读量463

点赞数 11

文章标签： leetcode 笔记算法

本文链接：https://blog.youkuaiyun.com/qq_45014958/article/details/136487332

版权

本文详细介绍了如何使用递归和迭代方法实现二叉树的前序、中序和后序遍历，包括示例代码和逻辑分析，适用于LeetCode相关算法学习。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、144. 二叉树的前序遍历 - 力扣（LeetCode）

1.1题目

给你二叉树的根节点 root ，返回它节点值的前序遍历。

示例 1：

输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

输入：root = [1,2]
输出：[1,2]

示例 5：

输入：root = [1,null,2]
输出：[1,2]

提示：

树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

1.2思路分析

方法一递归

方法二迭代

1.3代码实现

方法一递归

/**
 * 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是抽象类不能被实例化
        List<Integer> result = new ArrayList<>();
        preoder(root,result);
        return result;

    }
    // 前序遍历
    public void preoder (TreeNode root ,List<Integer>result){
        if(root == null){
            return ;
        }
        // 将根节点的值加入到结果集中
        result.add(root.val);
        // 递归将其左节点放入到结果集中
        preoder(root.left,result);
        preoder(root.right,result);
    }
}

方法二迭代

/**
 * 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> 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;

    }
}

二、94. 二叉树的中序遍历 - 力扣（LeetCode）

2.1题目

给定一个二叉树的根节点 root ，返回 它的中序遍历 。

示例 1：

输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

2.2思路分析

方法一递归

方法二迭代

2.3代码实现

方法一递归

/**
 * 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> result = new ArrayList<>();
        inorder(root,result);
        return result;
    }
    // 定义函数进行中序遍历
    public void inorder(TreeNode root, List<Integer> result){
        // 判断迭代的终止条件
        if(root == null) return;
        inorder(root.left,result);
        result.add(root.val);
        inorder(root.right,result);
    }
}

方法二迭代

/**
 * 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> result = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        if(root == null) return result;
        // 顶一个临时指针存放节点
        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;

    }
}

三、145. 二叉树的后序遍历 - 力扣（LeetCode）

3.1题目

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

示例 1：

输入：root = [1,null,2,3]
输出：[3,2,1]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

3.2思路分析

方法一递归

方法二迭代

3.3代码实现

方法一递归

/**
 * 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> result = new ArrayList<>();
        postorder(root,result);
        return result;

    }
    // 定义后续遍历函数
    public void postorder(TreeNode root,List<Integer>result){
        // 定义迭代终止的条件
        if(root == null){
            return;
        }
        postorder(root.left,result);
        postorder(root.right,result);
        result.add(root.val);
    }
}

方法二迭代

/**
 * 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> result = new ArrayList<>();
        Stack <TreeNode> stack = new Stack<>();
        // 当根节点为空时直接返回
        if(root == null) return result;
        // 将跟节点放入栈中
        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调用库函数
        Collections.reverse(result);
        return result; 
    }
}