代码随想录算法训练营day14| 二叉树的遍历

最新推荐文章于 2024-11-17 06:32:34 发布

KamenRojin

最新推荐文章于 2024-11-17 06:32:34 发布

阅读量223

点赞数 1

分类专栏：代码随想录文章标签： leetcode java Powered by 金山文档

本文链接：https://blog.csdn.net/qq_40995940/article/details/129542231

版权

代码随想录专栏收录该内容

19 篇文章 0 订阅

订阅专栏

该代码示例展示了如何使用Java进行二叉树的前序、中序和后序遍历，分别通过递归和迭代两种方法实现。递归方法按照根-左-右的顺序访问节点，而迭代方法利用栈来模拟递归过程，调整入栈和出栈顺序以达到相同的效果。

摘要由CSDN通过智能技术生成

144.二叉树的前序遍历(opens new window)

145.二叉树的后序遍历(opens new window)

94.二叉树的中序遍历

递归遍历

package _06binary_tree.day14._01traverse._01recursion;
// 二叉树的递归遍历（前中后序）

import java.util.ArrayList;
import java.util.List;

public class Solution {
    // 前序遍历
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        preOrder(root, res);
        return res;
    }
    // 前序遍历
    void preOrder(TreeNode root, List<Integer> res) {
        if(root == null)return; // 递归终止条件

        res.add(root.val); // 中
        preOrder(root.left,res); // 左
        preOrder(root.right,res); // 右
    }

    // 中序遍历
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        inOrder(root, res);
        return res;
    }
    // 中序遍历
    void inOrder(TreeNode root, List<Integer> res){
        if(root == null)return;

        inOrder(root.left,res); // 左
        res.add(root.val); // 中
        inOrder(root.right,res); // 右
    }

    // 后序遍历
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        postOrder(root, res);
        return res;
    }



    // 后序遍历
    void postOrder(TreeNode root, List<Integer> res){
        if(root == null)return;

        postOrder(root.left,res); // 左
        postOrder(root.right,res); // 右
        res.add(root.val); // 中
    }
}

// 定义树节点
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode() {
    }

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

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

非递归遍历

package _06binary_tree.day14._01traverse._02iteration;


import java.util.*;

public class Solution {
    // 前序遍历
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }

        Stack<TreeNode> stack = new Stack<>();
        // 根节点入栈
        stack.push(root);
        // 迭代遍历
        // 出栈顺序：中 - 左 - 右
        // 入栈顺序：中 - 右 - 左
        while (!stack.isEmpty()) {
            // 根节点出栈
            TreeNode node = stack.pop();
            // 访问
            res.add(node.val);
            // 若右子树非空，右孩子入栈
            if (node.right != null) {
                stack.push(root.right);
            }
            // 若左子树非空，左孩子入栈
            if (node.left != null) {
                stack.push(root.left);

            }
        }
        return res;
    }

    // 中序遍历
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null)return res;
        Stack<TreeNode> stack = new Stack<>();

        // 迭代遍历：左 - 中 - 右
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            // 指针一直往左
            if(cur.left != null){
                stack.push(cur);
                cur = cur.left;
            }else {
                // 直到左子树为空
                // 出栈并访问
                cur = stack.pop();
                res.add(cur.val);
                // 遍历右子树
                cur = cur.right;
            }
        }
        return res;
    }

    // 后序遍历
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null)return res;
        Stack<TreeNode> stack = new Stack<>();

        // 遍历顺序：左右中
        // 出栈顺序：中右左
        // 入栈顺序：中左右
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            res.add(node.val);
            if(node.left!=null){
                stack.push(node.left);
            }
            if(node.right!=null){
                stack.push(node.right);
            }
        }
        // 逆序
        Collections.reverse(res);
        return res;
    }
}

// 定义节点
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

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

    TreeNode(int val) {
        this.val = val;
    }

    TreeNode() {
    }
}