02_二叉树的迭代遍历

合集 - 数据结构与算法(61)

1.01_设计一个有getMin功能的栈2023-09-22 2.02_由两个栈组成的队列2023-09-26 3.03_如何仅用递归函数和栈操作逆序一个栈2023-09-27 4.04_猫狗队列2023-10-05 5.05_用一个栈实现另一个栈的排序2023-10-06 6.06_用栈来求解汉诺塔问题2023-10-08 7.07_用队列实现栈2023-10-09 8.09_删除字符串中的所有相邻重复项2023-10-13 9.08_ 有效的括号2023-10-11 10.10_逆波兰表达式求值2023-10-16 11.11_滑动窗口最大值2023-10-17 12.12_前K个高频元素2023-10-18 13.01_移除链表元素2023-10-23 14.02_设计链表2023-10-24 15.03_反转链表2023-10-25 16.04_两两交换链表中的节点2023-10-26 17.05_删除链表的倒数第N个节点2023-10-27 18.06_链表相交2023-10-31 19.07_环形链表2023-11-04 20.01_二叉树的递归遍历2023-11-06 21.二叉树理论基础2023-11-06

22.02_二叉树的迭代遍历2023-11-10

23.04_二叉树的层序遍历2023-11-10 24.05_二叉树的层次遍历II2023-11-16 25.06_二叉树的右视图2023-11-17 26.07_二叉树的层平均值2023-11-20 27.08_N叉树的层序遍历2023-11-23 28.09_每个行中找最大值2023-11-23 29.10_填充每个节点的下一个右侧节点指针2023-11-24 30.11_二叉树的最大深度2023-11-25 31.12_二叉树的最小深度2023-11-27 32.13_翻转二叉树2023-11-28 33.14_对称二叉树2023-11-30 34.15_完全二叉树的节点个数2023-12-06 35.16_平衡二叉树2023-12-06 36.17_二叉树的所有路径2023-12-06 37.18_左叶子之和2023-12-07 38.19_找树左下角的值2023-12-08 39.20_路径总和2023-12-09 40.21_从中序与后序遍历序列构造二叉树2023-12-20 41.22_最大二叉树2023-12-21 42.23_合并二叉树2023-12-22 43.24_二叉搜索树中的搜索2023-12-25 44.27_二叉搜索树的众数2024-01-09 45.28_二叉树的最近公共祖先2024-01-09 46.29_二叉搜索树中的插入操作2024-01-18 47.30_删除二叉搜索树中的节点2024-01-20 48.31_修剪二叉搜索树2024-01-20 49.32_将有序数组转换为平衡二叉搜索树2024-01-23 50.33_把二叉搜索树转换为累加树2024-01-24 51.动态规划理论2024-05-24 52.01_斐波那契数列2024-05-24 53.02_爬楼梯2024-05-24 54.03_使用最小花费爬楼梯2024-05-24 55.04_不同路径2024-05-25 56.05_不同路径2(带障碍物版)2024-05-25 57.06_整数拆分2024-05-27 58.08_杨辉三角2024-05-30 59.10_最后一块石头的重量2024-06-05 60.09_分割等和子集2024-06-05 61.74_搜索二维矩阵2024-07-20

二叉树的迭代遍历

// 前序遍历顺序：中-左-右，入栈顺序：中-右-左
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;
    }
}

// 中序遍历顺序: 左-中-右 入栈顺序： 左-右
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        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;
    }
}

// 后序遍历顺序 左-右-中 入栈顺序：中-左-右 出栈顺序：中-右-左， 最后翻转结果
class Solution {
    public List<Integer> postorderTraversal(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.left != null){
                stack.push(node.left);
            }
            if (node.right != null){
                stack.push(node.right);
            }
        }
        Collections.reverse(result);
        return result;
    }
}