在前序、中序、后序遍历中可以用以下步骤进行
- 前序遍历:
- 创建一个空栈,并将根节点压入栈中。
- 当栈不为空时:
- 弹出栈顶节点并处理(例如,打印)其值。
- 如果弹出的节点有右子节点,将其压入栈中。
- 如果弹出的节点有左子节点,将其压入栈中。
- 继续此过程,直到栈为空。
- 中序遍历:
- 初始化一个空栈,并将当前节点设置为根节点。
- 当栈不为空或当前节点不为空时:
- 如果当前节点不为空,将其压入栈中并移动到其左子节点。
- 如果当前节点为空,从栈中弹出顶部节点,处理其值,并将当前节点设置为其右子节点。
- 重复此过程,直到栈为空且当前节点为空。
- 后序遍历:
- 创建两个栈,stack1 和 stack2。
- 将根节点压入 stack1。
- 当 stack1 不为空时:
- 从 stack1 中弹出顶部节点并将其压入 stack2。
- 如果弹出的节点有左子节点,将其压入 stack1。
- 如果弹出的节点有右子节点,将其压入 stack1。
- 当 stack2 不为空时,弹出并处理其节点的值。
在二叉树遍历中,用栈对二叉树进行前序、中序、后序遍历代码如下
import java.io.Serializable;
import java.util.Stack;
class TreeNode implements Serializable {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) {
val = x;
}
}
public class BinaryTreeTraversal {
public static void main(String[] args) {
/**
* 1
* / \
* 2 3
* / \ / \
* 4 5 6 7
* / \ / \ / \ / \
* 8 9 10 11 12 13 14 15
*/
// 构建一个简单的二叉树
TreeNode root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(5);
root.right.left = new TreeNode(6);
root.right.right = new TreeNode(7);
root.left.left.left = new TreeNode(8);
root.left.left.right = new TreeNode(9);
root.left.right.left = new TreeNode(10);
root.left.right.right = new TreeNode(11);
root.right.left.left = new TreeNode(12);
root.right.left.right = new TreeNode(13);
root.right.right.left = new TreeNode(14);
root.right.right.right = new TreeNode(15);
System.out.println("前序遍历:");
preOrderTraversal(root);
System.out.println("\n中序遍历:");
inOrderTraversal(root);
System.out.println("\n后序遍历:");
postOrderTraversal(root);
}
// 前序遍历
public static void preOrderTraversal(TreeNode root) {
Stack<TreeNode> stack = new Stack<>(); // 创建一个空栈
stack.push(root); // 将根节点压入栈中
while (!stack.isEmpty()) {
// 当栈不为空时
TreeNode node = stack.pop(); // 弹出栈顶节点并处理其值
System.out.print(node.val + " ");
if (node.right != null) {
// 如果弹出的节点有右子节点,将其压入栈中
stack.push(node.right);
}
if (node.left != null) {
// 如果弹出的节点有左子节点,将其压入栈中
stack.push(node.left);
}
}
}
// 中序遍历
public static void inOrderTraversal(TreeNode root) {
Stack<TreeNode> stack = new Stack<>(); // 初始化一个空栈
TreeNode current = root; // 将当前节点设置为根节点
while (!stack.isEmpty() || current != null) {
// 当栈不为空或当前节点不为空时
if (current != null) {
// 如果当前节点不为空,将其压入栈中并移动到其左子节点
stack.push(current);
current = current.left;
} else {
// 如果当前节点为空,从栈中弹出顶部节点,处理其值,并将当前节点设置为其右子节点
TreeNode node = stack.pop();
System.out.print(node.val + " ");
current = node.right;
}
}
}
// 后序遍历
public static void postOrderTraversal(TreeNode root) {
Stack<TreeNode> stack1 = new Stack<>(); // 创建两个栈,stack1 和 stack2
Stack<TreeNode> stack2 = new Stack<>();
stack1.push(root); // 将根节点压入 stack1
while (!stack1.isEmpty()) {
// 当 stack1 不为空时
TreeNode node = stack1.pop(); // 从 stack1 中弹出顶部节点并将其压入 stack2
stack2.push(node);
if (node.left != null) {
// 如果弹出的节点有左子节点,将其压入 stack1
stack1.push(node.left);
}
if (node.right != null) {
// 如果弹出的节点有右子节点,将其压入 stack1
stack1.push(node.right);
}
}
while (!stack2.isEmpty()) {
// 当 stack2 不为空时,弹出并处理其节点的值
TreeNode node = stack2.pop();
System.out.print(node.val + " ");
}
}
}
结果输出
前序遍历:
1 2 4 8 9 5 10 11 3 6 12 13 7 14 15
中序遍历:
8 4 9 2 10 5 11 1 12 6 13 3 14 7 15
后序遍历:
8 9 4 10 11 5 2 12 13 6 14 15 7 3 1