public class TreeTraverse {
public static void main(String[] args) {
TreeNode root = new TreeNode(1);
TreeNode root1 = new TreeNode(2);
TreeNode root2 = new TreeNode(3);
root.right = root1;
root1.left = root2;
//前序遍历递归
System.out.println(preorderTraversal1(root));
//前序遍历循环
System.out.println(preorderTraversal(root));
//中序遍历递归
System.out.println(inorderTraversal1(root));
//中序遍历循环
System.out.println(inorderTraversal(root));
//后序遍历递归
System.out.println(postorderTraversal1(root));
//后序遍历循环
System.out.println(postorderTraversal(root));
}
//递归前序遍历二叉树
public static List<Integer> preorderTraversal1(TreeNode root) {
List<Integer> arr = new ArrayList<>();
preorderTraversal(arr, root);
return arr;
}
public static void preorderTraversal(List<Integer> arr, TreeNode root) {
if (root == null) return;
arr.add(root.val);
preorderTraversal(arr, root.left);
preorderTraversal(arr, root.right);
}
//循环前序遍历二叉树
public static List<Integer> preorderTraversal(TreeNode root) {
List<Integer> arr = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
while (root != null || !stack.isEmpty()) {
if (root != null) {
arr.add(root.val);
stack.push(root);
root = root.left;
} else {
root = stack.pop();
root = root.right;
}
}
return arr;
}
//递归中序遍历二叉树
public static List<Integer> inorderTraversal1(TreeNode root) {
List<Integer> arr = new ArrayList<>();
inorderTraversal(arr, root);
return arr;
}
public static void inorderTraversal(List<Integer> arr, TreeNode root) {
if (root == null) return;
inorderTraversal(arr, root.left);
arr.add(root.val);
inorderTraversal(arr, root.right);
}
//循环中序遍历二叉树
public static List<Integer> inorderTraversal(TreeNode root) {
List<Integer> arr = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
while (root != null || !stack.isEmpty()) {
if (root != null) {
stack.push(root);
root = root.left;
} else {
root = stack.pop();
arr.add(root.val);
root = root.right;
}
}
return arr;
}
//递归后序遍历二叉树
public static List<Integer> postorderTraversal1(TreeNode root) {
List<Integer> arr = new ArrayList<>();
postorderTraversal(arr, root);
return arr;
}
public static void postorderTraversal(List<Integer> arr, TreeNode root) {
if (root == null) return;
postorderTraversal(arr, root.left);
postorderTraversal(arr, root.right);
arr.add(root.val);
}
//循环后序遍历二叉树
public static List<Integer> postorderTraversal(TreeNode root) {
List<Integer> arr = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
TreeNode pre = null;
while (root != null || !stack.isEmpty()) {
if (root != null && root != pre) {
stack.push(root);
root = root.left;
} else {
root = stack.peek();
if (root.right != null && root.right != pre) {
root = root.right;
} else {
root = stack.pop();
arr.add(root.val);
pre = root;
}
}
if (stack.isEmpty()){
break;
}
}
return arr;
}
public static 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;
}
}
}
二叉树前、中、后序遍历,递归加迭代——Leetcode
于 2022-04-20 15:03:21 首次发布