二叉树的遍历（Java）

二叉树的遍历分为：前序遍历，中序遍历，后序遍历，层次遍历。本文主要讲述二叉树的前中后序遍历的递归实现和非递归实现（Java代码实现）。

先上一个二叉树，我们来看看它的前中后序输出分别是什么：

接下来我们用代码实现：

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

public class Tree {
	//前序递归使用
	List<Integer> bforder=new ArrayList<>();
	//中序递归使用
	List<Integer> inorder=new ArrayList<>();
	//后序递归使用
	List<Integer> aforder=new ArrayList<>();
	
	//递归前序遍历二叉树
	public List<Integer> bforderTraversal(TreeNode root) {
		bforder(root);
		return bforder;
	}
	void bforder(TreeNode root){
		if(root==null){
			return;
		}
		bforder.add(root.val);
		bforder(root.left);
		bforder(root.right);
	}
	
	//不递归前序遍历二叉树
	public List<Integer> bforderTraversal1(TreeNode root) {
		List<Integer> res= new ArrayList<>();
		Stack<TreeNode> s=new Stack<>();
		if(root==null){
			return res;
		}
		s.push(root);
		while(!s.isEmpty()){
			TreeNode p=s.pop();
			res.add(p.val);
			if(p.right!=null){
				s.push(p.right);
			}
			if(p.left!=null){
				s.push(p.left);
			}
		}
		return res;
	}
	
	//递归中序遍历二叉树
	public List<Integer> inorderTraversal(TreeNode root) {
		inorder(root);
		return inorder;
	}
	void inorder(TreeNode root){
		if(root==null){
			return;
		}
		inorder(root.left);
		inorder.add(root.val);
		inorder(root.right);
	}
	//非递归中序遍历二叉树
	public List<Integer> inorderTraversal1(TreeNode root) {
		List<Integer> res= new ArrayList<>();
		if(root==null){
			return res;
		}
		Stack<TreeNode> s=new Stack<>();
		TreeNode p=root;
		while(p!=null || !s.isEmpty()){
			while(p!=null){
				s.push(p);
				p=p.left;
			}
			if(!s.empty()){
				p=s.pop();
				res.add(p.val);
				p=p.right;
			}
		}
		return res;
	}
	
	//递归后序遍历二叉树
	public List<Integer> aforderTraversal(TreeNode root) {
		aforder(root);
		return aforder;
	}
	void aforder(TreeNode root){
		if(root==null){
			return;
		}
		aforder(root.left);
		aforder(root.right);
		aforder.add(root.val);
	}
	//非递归后序遍历二叉树
	public List<Integer> aforderTraversal1(TreeNode root) {
		List<Integer> res= new ArrayList<>();
		Stack<TreeNode> s=new Stack<>();
		if(root==null){
			return res;
		}
		s.push(root);
		TreeNode cur=root;
		TreeNode pre=null;
		while(!s.isEmpty()){
			cur=s.peek();
            if((cur.left==null&&cur.right==null)||((pre!=null)&&(pre==cur.left||pre==cur.right))) {
                res.add(cur.val);
                s.pop();
                pre=cur; //注意这里，pre仅仅在输出了cur的时候下才更新。
            }else{
                if(cur.right!=null)
                    s.push(cur.right);
                if(cur.left!=null)
                    s.push(cur.left);
            }
		}
		return res;
	}
	//非递归后序遍历二叉树
	public List<Integer> aforderTraversal2(TreeNode root) {
		List<Integer> res= new ArrayList<>();
		Stack<TreeNode> s=new Stack<>();
		if(root==null){
			return res;
		}
		s.push(root);
		while(!s.isEmpty()){
			TreeNode p=s.pop();
			res.add(p.val);
			if(p.left!=null){
				s.push(p.left);
			}
			if(p.right!=null){
				s.push(p.right);
			}
		}
		Collections.reverse(res);
		return res;
	}
	
	
	@Test
	public void test(){
		TreeNode root =new TreeNode(10);
		TreeNode node1=new TreeNode(2);
		TreeNode node2=new TreeNode(5);
		TreeNode node3=new TreeNode(8);
		TreeNode node4=new TreeNode(7);
		TreeNode node5=new TreeNode(6);
		root.left=node1;
		root.right=node2;
		node1.left=node3;
		node2.left=node4;
		node2.right=node5;
		
		//测试前序遍历(非递归)
		System.out.println("前序遍历(非递归):");
		System.out.println(bforderTraversal1(root));
		//测试前序遍历(递归)
		System.out.println("前序遍历(递归):");
		System.out.println(bforderTraversal(root));
		
		
		//测试中序遍历(非递归)
		System.out.println("中序遍历(非递归):");
		System.out.println(inorderTraversal1(root));
		//测试中序遍历(递归)
		System.out.println("中序遍历(递归):");
		System.out.println(inorderTraversal(root));
		
		
		//测试后序遍历(非递归)
		System.out.println("后序遍历(非递归):");
		System.out.println(aforderTraversal2(root));
		//测试后序遍历(递归)
		System.out.println("后序遍历(递归):");
		System.out.println(aforderTraversal(root));
	}
}

运行结果：

前序遍历(非递归):
[10, 2, 8, 5, 7, 6]
前序遍历(递归):
[10, 2, 8, 5, 7, 6]
中序遍历(非递归):
[8, 2, 10, 7, 5, 6]
中序遍历(递归):
[8, 2, 10, 7, 5, 6]
后序遍历(非递归):
[8, 2, 7, 6, 5, 10]
后序遍历(递归):
[8, 2, 7, 6, 5, 10]