树的遍历实现
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;
}
}
浙公网安备 33010602011771号