树的节点定义如下
package traversal;
public class TreeNode<T> {
public T value;
public TreeNode<T> left;
public TreeNode<T> right;
public TreeNode(T value) {
this.value = value;
this.left = null;
this.right = null;
}
}
前序遍历
package traversal;
import java.util.*;
/**
* 前序遍历:先访问根节点,再访问左子节点,最后访问右子节点
*/
public class PreOrder {
public static List<Integer> traversalRecursively(TreeNode<Integer> root) {
List<Integer> list = new ArrayList<>();
if (root == null)
return list;
list.add(root.value);
list.addAll(traversalRecursively(root.left));
list.addAll(traversalRecursively(root.right));
return list;
}
public static List<Integer> traversalIteratively(TreeNode<Integer> root) {
// 栈顶元素永远为current的父节点
Deque<TreeNode<Integer>> stack = new ArrayDeque<>();
TreeNode<Integer> current = root;
List<Integer> list = new LinkedList<>();
if (root == null)
return list;
while (current != null || !stack.isEmpty()) {
if (current != null) {
list.add(current.value);
stack.push(current);
current = current.left;
} else {
current = stack.pop().right;
}
}
return list;
}
public static void main(String[] args) {
TreeNode<Integer> root = new TreeNode<>(10);
root.left = new TreeNode<>(6);
root.right = new TreeNode<>(14);
root.left.left = new TreeNode<>(4);
root.left.right = new TreeNode<>(8);
root.right.left = new TreeNode<>(12);
root.right.right = new TreeNode<>(16);
System.out.println(traversalRecursively(root));
System.out.println(traversalIteratively(root));
}
}
中序遍历
package traversal;
import java.util.*;
/**
* 中序遍历:先访问左子节点,再访问根节点,最后访问右子节点
*/
public class InOrder {
public static List<Integer> traversalRecursively(TreeNode<Integer> root) {
List<Integer> list = new ArrayList<>();
if (root == null)
return list;
list.addAll(traversalRecursively(root.left));
list.add(root.value);
list.addAll(traversalRecursively(root.right));
return list;
}
public static List<Integer> traversalIteratively(TreeNode<Integer> root) {
// 栈顶元素永远为current的父节点
Deque<TreeNode<Integer>> stack = new ArrayDeque<>();
TreeNode<Integer> current = root;
List<Integer> list = new LinkedList<>();
while (current != null || !stack.isEmpty()) {
if (current != null) {
stack.push(current);
current = current.left;
} else {
list.add(stack.peek().value);
current = stack.pop().right;
}
}
return list;
}
public static void main(String[] args) {
TreeNode<Integer> root = new TreeNode<>(10);
root.left = new TreeNode<>(6);
root.right = new TreeNode<>(14);
root.left.left = new TreeNode<>(4);
root.left.right = new TreeNode<>(8);
root.right.left = new TreeNode<>(12);
root.right.right = new TreeNode<>(16);
System.out.println(traversalRecursively(root));
System.out.println(traversalIteratively(root));
}
}
后序遍历
package traversal;
import java.util.*;
/**
* 后序遍历:先访问左子节点,再访问访问右子节点,最后根节点
*/
public class PostOrder {
public static List<Integer> traversalRecursively(TreeNode<Integer> root) {
List<Integer> list = new ArrayList<>();
if (root == null)
return list;
list.addAll(traversalRecursively(root.left));
list.addAll(traversalRecursively(root.right));
list.add(root.value);
return list;
}
public static List<Integer> traversalIteratively(TreeNode<Integer> root) {
// 栈顶元素永远为current的父节点
// previousVisted用于区分是从左子树还是右子树返回的
Deque<TreeNode<Integer>> stack = new ArrayDeque<>();
TreeNode<Integer> current = root;
TreeNode<Integer> previousVisted = null;
List<Integer> list = new LinkedList<>();
while (current != null || !stack.isEmpty()) {
if (current != null) {
stack.push(current);
current = current.left;
} else {
current = stack.peek().right;
if (current != null && current != previousVisted) {
stack.push(current);
current = current.left;
} else {
previousVisted = stack.pop();
list.add(previousVisted.value);
current = null;
}
}
}
return list;
}
public static void main(String[] args) {
TreeNode<Integer> root = new TreeNode<>(10);
root.left = new TreeNode<>(6);
root.right = new TreeNode<>(14);
root.left.left = new TreeNode<>(4);
root.left.right = new TreeNode<>(8);
root.right.left = new TreeNode<>(12);
root.right.right = new TreeNode<>(16);
System.out.println(traversalRecursively(root));
System.out.println(traversalIteratively(root));
}
}
层序遍历
package traversal;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class LevelOrder {
public static List<Integer> traversal(TreeNode<Integer> root) {
Queue<TreeNode<Integer>> queue = new LinkedList<>();
List<Integer> list = new LinkedList<>();
TreeNode<Integer> node = null;
if (root == null)
return list;
queue.add(root);
while (!queue.isEmpty()) {
node = queue.poll();
list.add(node.value);
if (node.left != null)
queue.offer(node.left);
if (node.right != null)
queue.offer(node.right);
}
return list;
}
public static void main(String[] args) {
TreeNode<Integer> root = new TreeNode<>(10);
root.left = new TreeNode<>(6);
root.right = new TreeNode<>(14);
root.left.left = new TreeNode<>(4);
root.left.right = new TreeNode<>(8);
root.right.left = new TreeNode<>(12);
root.right.right = new TreeNode<>(16);
System.out.println(traversal(root));
}
}