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

• 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 preorderTraversal(TreeNode root) {
        List res = new ArrayList<>();
        preOrder(root, res);
        return res;
    }
    // 前序遍历
    void preOrder(TreeNode root, List res) {
        if(root == null)return; // 递归终止条件

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

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

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

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



    // 后序遍历
    void postOrder(TreeNode root, List 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 preorderTraversal(TreeNode root) {
        List res = new ArrayList<>();
        if (root == null) {
            return res;
        }

        Stack 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 inorderTraversal(TreeNode root) {
        List res = new ArrayList<>();
        if(root == null)return res;
        Stack 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 postorderTraversal(TreeNode root) {
        List res = new ArrayList<>();
        if(root == null)return res;
        Stack 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() {
    }
}