树的遍历实现

LeetCode 144. 二叉树的前序遍历

前序遍历的顺序是：根节点 → 左子树 → 右子树

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;public class BinaryTreePreorderTraversal {public static void main(String[] args) {Solution solution = new BinaryTreePreorderTraversal().new Solution();}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<>();
//        traversal(root, result);
//        return result;return traversal(root);}// 遍历（递归实现）public void traversal(TreeNode root, List<Integer> result) {if (root == null) {return;}result.add(root.val); // 前序遍历在这里添加根节点traversal(root.left, result);traversal(root.right, result);}// 遍历（迭代实现）public List<Integer> traversal(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> preorderTraversal(TreeNode root) {List<Integer> result = new ArrayList<>();Stack<TreeNode> stack = new Stack<>();TreeNode curr = root;while (curr != null || !stack.isEmpty()) {// 一直往左走，边走边访问while (curr != null) {result.add(curr.val); // 访问当前节点stack.push(curr);     // 保存节点用于后续访问右子树curr = curr.left;     // 移动到左子节点}// 回溯到上一个节点并转向右子树curr = stack.pop();curr = curr.right;}return result;}
}

LeetCode 94. 二叉树的中序遍历

中序遍历的顺序是：左子树 → 根节点 → 右子树

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;public class BinaryTreeInorderTraversal {public static void main(String[] args) {Solution solution = new BinaryTreeInorderTraversal().new Solution();}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<>();
//        traversal(root, result);
//        return result;return traversal(root);}// 遍历（递归实现）public void traversal(TreeNode root, List<Integer> result) {if (root == null) {return;}traversal(root.left, result);result.add(root.val); // 中序遍历在这里添加根节点（但是不是本题目）traversal(root.right, result);}public List<Integer> traversal(TreeNode root) {List<Integer> result = new ArrayList<>();Stack<TreeNode> stack = new Stack<>();TreeNode curr = root;while (curr != null || !stack.isEmpty()) {// 一直往左走，把所有左子节点入栈while (curr != null) {stack.push(curr);curr = curr.left;}// 弹出栈顶节点（最左边的节点）curr = stack.pop();result.add(curr.val); // 访问当前节点// 转向右子树curr = curr.right;}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 curr = root;while (curr != null || !stack.isEmpty()) {if (curr != null) {stack.push(curr);curr = curr.left; // 先处理左子树} else {curr = stack.pop();result.add(curr.val); // 访问根节点curr = curr.right;    // 再处理右子树}}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<>();stack.push(root);while (!stack.isEmpty()) {TreeNode node = stack.pop();if (node != null) {// 右子节点入栈if (node.right != null) {stack.push(node.right);}// 当前节点再次入栈，前面加一个null标记stack.push(node);stack.push(null);// 左子节点入栈if (node.left != null) {stack.push(node.left);}} else {// 遇到null标记，弹出下一个节点并访问node = stack.pop();result.add(node.val);}}return result;}
}

LeetCode 145. 二叉树的后序遍历

后序遍历的顺序是：左子树 → 右子树 → 根节点

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;public class BinaryTreePostorderTraversal {public static void main(String[] args) {Solution solution = new BinaryTreePostorderTraversal().new Solution();}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<>();
//        traversal(root, result);
//        return result;return traversal(root);}// 遍历（递归实现）public void traversal(TreeNode root, List<Integer> result) {if (root == null) {return;}traversal(root.left, result);traversal(root.right, result);result.add(root.val); // 后序遍历在这里添加根节点}public List<Integer> traversal(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;}}
}

迭代写法二

class Solution {public List<Integer> postorderTraversal(TreeNode root) {List<Integer> result = new ArrayList<>();if (root == null) {return result;}Stack<TreeNode> stack = new Stack<>();TreeNode curr = root;TreeNode prev = null; // 记录上一个访问的节点while (curr != null || !stack.isEmpty()) {// 一直往左走while (curr != null) {stack.push(curr);curr = curr.left;}curr = stack.peek();// 如果右子树为空或者右子树已经访问过，则访问当前节点if (curr.right == null || curr.right == prev) {result.add(curr.val);stack.pop();prev = curr;curr = null; // 当前节点处理完毕，继续回溯} else {// 转向右子树curr = curr.right;}}return result;}
}

双栈法

class Solution {public List<Integer> postorderTraversal(TreeNode root) {List<Integer> result = new ArrayList<>();if (root == null) {return result;}Stack<TreeNode> stack1 = new Stack<>();Stack<TreeNode> stack2 = new Stack<>();stack1.push(root);while (!stack1.isEmpty()) {TreeNode node = stack1.pop();stack2.push(node); // 将节点压入第二个栈// 先左后右，这样第二个栈出栈时就是先右后左if (node.left != null) {stack1.push(node.left);}if (node.right != null) {stack1.push(node.right);}}// 从第二个栈弹出，得到后序遍历结果while (!stack2.isEmpty()) {result.add(stack2.pop().val);}return result;}
}