前序，中序，后序，广度优先，深度优先的代码实现

先定义一个TreeNode类：

package exer.leetcode;

public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }

@Override
public String toString() {
return "TreeNode [val=" + val + ", left=" + left + ", right=" + right + "]";
}


}

 

package exer.leetcode;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class OrderTraversal {
public static void main(String[] args) {
TreeNode root = new TreeNode(1);
root.left = new TreeNode(2);
root.left.right = new TreeNode(3);
root.left.right.left = new TreeNode(4);
root.right = new TreeNode(5);
root.right.right = new TreeNode(6);
root.right.right.left = new TreeNode(7);
root.right.right.left.left = new TreeNode(8);
root.right.right.left.right = new TreeNode(9);
List<Integer> preOrderlist = preOrderTraversal(root);
List<Integer> inOrderlist = inOrderTraversal(root);
List<Integer> postOrderlist = postOrderTraversal(root);
depthOrderTraversalWithRecursive(root);
List<Integer> breadthFirstList = breadthFirstTraversal(root);
System.out.println("preOrderlist:" + preOrderlist);
System.out.println("inOrderlist:" + inOrderlist);
System.out.println("postOrderlist:" + postOrderlist);
System.out.println(breadthFirstList);
}

public static List<Integer> preOrderTraversal(TreeNode root){
List<Integer> list = new ArrayList<>();
preOrderTraversal(root,list);
return list;
}

public static List<Integer> inOrderTraversal(TreeNode root){
List<Integer> list = new ArrayList<>();
inOrderTraversal(root,list);
return list;
}

public static List<Integer> postOrderTraversal(TreeNode root){
List<Integer> list = new ArrayList<>();
postOrderTraversal(root,list);
return list;
}

 

//前序遍历(根 - 左 - 右)
public static void preOrderTraversal(TreeNode root, List<Integer> list) {
if(root == null)
return;
list.add(root.val);
preOrderTraversal(root.left, list);
preOrderTraversal(root.right, list);
}

//中序遍历(左 - 根 - 右)
private static void inOrderTraversal(TreeNode root, List<Integer> list) {
if(root == null)
return;
inOrderTraversal(root.left, list);
list.add(root.val);
inOrderTraversal(root.right, list);
}

// 后序遍历(左 - 右 - 根)
private static void postOrderTraversal(TreeNode root, List<Integer> list) {
if(root == null)
return;
postOrderTraversal(root.left, list);
postOrderTraversal(root.right, list);
list.add(root.val);
}

//深度优先遍历(递归实现)相当于二叉树当中的前序遍历
public static void depthOrderTraversalWithRecursive(TreeNode root){
depthTraversal(root);
}

public static void depthTraversal(TreeNode tn){
if (tn != null){
System.out.print(tn.val+" ");
depthTraversal(tn.left);
depthTraversal(tn.right);
}
}

//广度优先遍历(队列实现)(相当于二叉树当中的按层次遍历)
public static List<Integer> breadthFirstTraversal(TreeNode root){
List<Integer> list = new ArrayList<>();
if(root == null)
return list;
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while(!queue.isEmpty()){
TreeNode treeNode = queue.poll();
if(treeNode.left != null)
queue.offer(treeNode.left);
if(treeNode.right != null)
queue.offer(treeNode.right);
list.add(treeNode.val);
}
return list;
}

}