package 二叉树遍历;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
public class BinaryTree {
// 二叉树结点
public static class BinaryTreeNode {
int value;
BinaryTreeNode left;
BinaryTreeNode right;
public BinaryTreeNode(int value) {
this.value = value;
}
public BinaryTreeNode(int value, BinaryTreeNode left, BinaryTreeNode right) {
this.value = value;
this.left = left;
this.right = right;
}
}
// 访问树的结点
public static void visit(BinaryTreeNode node) {
System.out.println(node.value);
}
// 递归版先序遍历
public static void preOrder(BinaryTreeNode node) {
if (node != null) {
visit(node);
preOrder(node.left);
preOrder(node.right);
}
}
// 递归版中序遍历
public static void inOrder(BinaryTreeNode node) {
if (node != null) {
inOrder(node.left);
visit(node);
inOrder(node.right);
}
}
// 递归版后序遍历
public static void postOrder(BinaryTreeNode node) {
if (node != null) {
postOrder(node.left);
postOrder(node.right);
visit(node);
}
}
// 非递归版先序遍历
public static void iterativePreOrder(BinaryTreeNode node) {
if (node == null) {
return;
}
Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
stack.push(node);
while (!stack.isEmpty()) {
BinaryTreeNode temp = stack.pop();
visit(node);
if (node.right != null) {
stack.push(node.right);
}
if (node.left != null) {
stack.push(node.left);
}
}
}
// 非递归版中序遍历
public static void iterativeInOrder(BinaryTreeNode node) {
if (node == null) {
return;
}
Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
while (node != null || !stack.isEmpty()) {
while (node != null) {
stack.push(node);
node = node.left;
}
if (!stack.isEmpty()) {
node = stack.pop();
visit(node);
node = node.right;
}
}
}
// 非递归版单栈后序遍历
public static void iterativePostOrder(BinaryTreeNode node) {
if (node == null) {
return;
}
Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
BinaryTreeNode preNode = null;
while (node != null || !stack.isEmpty()) {
while (node != null) {
stack.push(node);
node = node.left;
}
BinaryTreeNode temp;
if (!stack.isEmpty()) {
temp = stack.peek().right;
if (temp == null || temp == preNode) {
node = stack.pop();
visit(node);
preNode = node;
node = null;
} else {
node = temp;
}
}
}
}
// 非递归双栈后序遍历
public static void iterativePostOrderBytwoStacks(BinaryTreeNode node) {
if (node == null) {
return;
}
Stack<BinaryTreeNode> stack = new Stack<>();
Stack<BinaryTreeNode> temp = new Stack<>();
while (node != null || !stack.isEmpty()) {
while (node != null) {
stack.push(node);
temp.push(node);
node = node.right;
}
BinaryTreeNode cc = null;
if (!stack.isEmpty()) {
node = stack.pop().left;
}
}
while (!temp.isEmpty()) {
node = temp.pop();
visit(node);
}
}
public static void layerTraversal(BinaryTreeNode root) {
Queue<BinaryTreeNode> queue = new LinkedList<>();
if (root != null) {
queue.add(root);
while (!queue.isEmpty()) {
BinaryTreeNode currentNode = queue.poll();
visit(currentNode);
if (currentNode.left != null) {
queue.add(currentNode.left);
}
if (currentNode.right != null) {
queue.add(currentNode.right);
}
}
}
}
}