二叉树的遍历

树节点类：
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }
}

先序遍历：

递归：

public ArrayList<Integer> preOrderTraverseRecur(TreeNode root) {
	if(root == null) {
		return null;
	}
		
	ArrayList<Integer> result = new ArrayList<Integer>();
	result.add(root.val);
	if(root.left != null) {
	<span style="white-space: pre;">	</span>result.addAll(preOrderTraverseRecur(root.left));
	}
	if(root.right != null) {
		result.addAll(preOrderTraverseRecur(root.right));
	}
		</span>

return result;
		
}

非递归

public ArrayList<Integer> preOrderTraverseNoRecur(TreeNode root) {
		if(root == null) {
			return null;
		}
		ArrayList<Integer> result = new ArrayList<Integer>();
		Stack<TreeNode> stack = new Stack<TreeNode>();
		stack.push(root);
		result.add(root.val);
		
		while(!stack.empty()) {
			if(stack.peek().left != null && 
					!result.contains(stack.peek().left.val)) {			
				result.add(stack.peek().left.val);
				stack.push(stack.peek().left);
			} else {
				if(stack.peek().right != null && 
						!result.contains(stack.peek().right.val)) {
					result.add(stack.peek().right.val);
					stack.push(stack.peek().right);
				} else {
					stack.pop();
				}			
			}
		}
		
		return result;
	}

中序遍历：

递归：

public ArrayList<Integer> inOrderTraverseRecur(TreeNode root) {
		if(root == null) {
			return null;
		}
		
		ArrayList<Integer> result = new ArrayList<Integer>();
		if(root.left != null) {
			result.addAll(inOrderTraverseRecur(root.left));
		}
		result.add(root.val);
		if(root.right != null) {
			result.addAll(inOrderTraverseRecur(root.right));
		}
		return result;
		
	}

非递归：

public ArrayList<Integer> inOrderTraverseNoRecur(TreeNode root) {
		if(root == null) {
			return null;
		}
		ArrayList<Integer> result = new ArrayList<Integer>();
		Stack<TreeNode> stack = new Stack<TreeNode>();
		stack.push(root);
		
		while(!stack.empty()) {
			if(stack.peek().left != null && 
					!result.contains(stack.peek().left.val)) {			
				stack.push(stack.peek().left);
			} else {
				if(stack.peek().right != null && 
						!result.contains(stack.peek().right.val)) {
					TreeNode temp = stack.peek();
					result.add(stack.pop().val);
					stack.push(temp.right);
				} else {
					result.add(stack.pop().val);
				}		
			}
		}
		
		return result;
	}

后序遍历：

递归：

public ArrayList<Integer> postOrderTraverseRecur(TreeNode root) {
		if(root == null) {
			return null;
		}
		
		ArrayList<Integer> result = new ArrayList<Integer>();
		if(root.left != null) {
			result.addAll(postOrderTraverseRecur(root.left));
		}
		if(root.right != null) {
			result.addAll(postOrderTraverseRecur(root.right));
		}
		result.add(root.val);
		return result;
		
	}

非递归：

public ArrayList<Integer> postOrderTraverseNoRecur(TreeNode root) {
		if(root == null) {
			return null;
		}
		
		ArrayList<Integer> result = new ArrayList<Integer>();
		Stack<TreeNode> stack = new Stack<TreeNode>();
		stack.push(root);
		
		while(!stack.empty()) {
			if(stack.peek().left != null && 
					!result.contains(stack.peek().left.val)) {			
				stack.push(stack.peek().left);
			} else {
				if(stack.peek().right != null && 
						!result.contains(stack.peek().right.val)) {
					stack.push(stack.peek().right);
				} else {
					result.add(stack.pop().val);
				}		
			}
		}
		
		return result;
		
	}

层序遍历：

public ArrayList<Integer> levelOrderTraverse(TreeNode root) {
		if(root == null) {
			return null;
		}
		LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        ArrayList<Integer> result = new ArrayList<Integer>();
        
        queue.add(root);
        result.add(root.val);
        
        while(!(queue.size() == 0)) { 
            TreeNode head = queue.remove();
            if(head.left != null ) {
                queue.add(head.left);
                result.add(head.left.val);
            } 
            
            if(head.right != null ) {
                queue.add(head.right);
                result.add(head.right.val);
            }     
        }
        
        return result;
    
	}

结果测试：

Test.java:

import java.util.ArrayList;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		/**
		 * 构建一颗二叉树

		 * 		    1
		 * 		  /   \
		 *     		 2     3
		 *             /  \     \
		 *           7    4     8
		 *          / \   /
		 *         6   5 9
		 */
		BinaryTree bt = new BinaryTree();
		TreeNode root = new TreeNode(1);		
		TreeNode node1 = new TreeNode(2);
		TreeNode node2 = new TreeNode(3);
		TreeNode node3 = new TreeNode(7);
		TreeNode node4 = new TreeNode(4);
		TreeNode node5 = new TreeNode(8);
		TreeNode node6 = new TreeNode(6);
		TreeNode node7 = new TreeNode(5);
		TreeNode node8 = new TreeNode(9);
		
		root.left = node1;
		root.right = node2;
		node1.left = node3;
		node1.right = node4;
		node2.right = node5;
		node4.left = node6;
		node4.right = node7;
		node5.left = node8;
		
		/**
		 *   测试递归先序遍历
		 *   正确输出为：   1  2  7  4  6  5  3  8  9 
		 */
        ArrayList<Integer> preOrderResultRecur = new ArrayList<Integer>();
        preOrderResultRecur = bt.preOrderTraverseRecur(root);
        System.out.println("递归先序遍历的结果为：   ");
        for(Integer integer : preOrderResultRecur) {
        	System.out.print(integer + "  ");
        }
        System.out.println();
        
        /**
		 *   测试非递归先序遍历
		 *   正确输出为：   1  2  7  4  6  5  3  8  9 
		 */
        ArrayList<Integer> preOrderResultNoRecur = new ArrayList<Integer>();
        preOrderResultNoRecur = bt.preOrderTraverseNoRecur(root);
        System.out.println("非递归先序遍历的结果为：   ");
        for(Integer integer : preOrderResultNoRecur) {
        	System.out.print(integer + "  ");
        }
        System.out.println();
        
        
        /**
		 *   测试递归中序遍历
		 *   正确输出为：    7  2  6  4  5  1  3  9  8
		 */
        ArrayList<Integer> inOrderResultRecur = new ArrayList<Integer>();
        inOrderResultRecur = bt.inOrderTraverseRecur(root);
        System.out.println("递归中序遍历的结果为：   ");
        for(Integer integer : inOrderResultRecur) {
        	System.out.print(integer + "  ");
        }
        System.out.println();
        
        /**
		 *   测试非递归中序遍历
		 *   正确输出为：     7  2  6  4  5  1  3  9  8 
		 */
        ArrayList<Integer> inOrderResultNoRecur = new ArrayList<Integer>();
        inOrderResultNoRecur = bt.inOrderTraverseNoRecur(root);
        System.out.println("非递归中序遍历的结果为：   ");
        for(Integer integer : inOrderResultNoRecur) {
        	System.out.print(integer + "  ");
        }
        System.out.println();
        
        /**
		 *   测试递归后序遍历
		 *   正确输出为：    7  6  5  4  2  9  8  3  1
		 */
        ArrayList<Integer> postOrderResultRecur = new ArrayList<Integer>();
        postOrderResultRecur = bt.postOrderTraverseRecur(root);
        System.out.println("递归后序遍历的结果为：   ");
        for(Integer integer : postOrderResultRecur) {
        	System.out.print(integer + "  ");
        }
        System.out.println();
        
        /**
		 *   测试非递归后序遍历
		 *   正确输出为：    7  6  5  4  2  9  8  3  1
		 */
        ArrayList<Integer> postOrderResultNoRecur = new ArrayList<Integer>();
        postOrderResultNoRecur = bt.postOrderTraverseNoRecur(root);
        System.out.println("非递归后序遍历的结果为：   ");
        for(Integer integer : postOrderResultNoRecur) {
        	System.out.print(integer + "  ");
        }
        System.out.println();
        
        /**
		 *   测试层序遍历
		 *   正确输出为：    1  2  3  7  4  8  6  5  9
		 */
        ArrayList<Integer> levelOrderResult = new ArrayList<Integer>();
        levelOrderResult = bt.levelOrderTraverse(root);
        System.out.println("层序遍历的结果为：   ");
        for(Integer integer : levelOrderResult) {
        	System.out.print(integer + "  ");
        }
        System.out.println(); 
	}

}

结果输出：