二叉树的遍历-Java实现

1.前序遍历

public class preOrder {
	public void preOrder(TreeNode root){
		if(root == null)
			return;		
		Stack<TreeNode> stack = new Stack<>();
		stack.push(root);
		while(!stack.isEmpty()) {
			TreeNode node = stack.pop();
			System.out.println(node.val);
			if(node.right != null)
				stack.push(node.right);
			if(node.left != null)
				stack.push(node.left);
		}
	}
	
	public void preOrder1(TreeNode root){
		if(root == null) 
			return;		
		System.out.println(root.val);
		preOrder1(root.left);
		preOrder1(root.right);
	
	}	
}

2.中序遍历

public class inOrder {
	public void inOrder(TreeNode root){
		if(root == null)
			return;		
		Stack<TreeNode> stack = new Stack<>();
		TreeNode cur = root;
		while(!stack.isEmpty() || cur != null) {
			while(cur != null) {
				stack.push(cur);
				cur = cur.left;
			}
			cur = stack.pop();
			System.out.println(cur.val);;
			cur = cur.right;
		}
	}
	
	public void inOrder1(TreeNode root){
		if(root == null) 
			return;		
		inOrder1(root.left);
		System.out.println(root.val);
		inOrder1(root.right);
		
	}
}

3.后序遍历

public class postOrder {
	public static void postOrder(TreeNode root) {
	    Stack<TreeNode> stack = new Stack<TreeNode>();
	    TreeNode cur = root; //记录当前节点
	    TreeNode lastVisit = root; //记录上次访问的节点
	    while (cur != null || !stack.isEmpty()) {
	        while (cur != null) {
	            stack.push(cur);
	            cur = cur.left;
	        }
	        //查看当前栈顶元素
	        cur = stack.peek();
	        //如果其右子树也为空，或者右子树已经访问
	        //则可以直接输出当前节点的值
	        if (cur.right == null || cur.right == lastVisit) {
	            System.out.print(cur.val + " ");
	            stack.pop();
	            lastVisit = cur;
	            cur = null;
	        } else {
	            //否则，继续遍历右子树
	            cur = cur.right;
	        }
	    }
	}
	
	public void postOrder1(TreeNode root){
		if(root == null) 
			return;		
		postOrder1(root.left);		
		postOrder1(root.right);
		System.out.println(root.val);		
	}
}

4.层序遍历

public class levelOrder {
	public void levelOrder(TreeNode root) {
		if(root == null)
			return;
		Queue<TreeNode> queue = new LinkedList<>();
		queue.offer(root);
		while(!queue.isEmpty()) {
			TreeNode node = queue.poll();
			System.out.println(node.val);
			if(node.left != null)
				queue.offer(node.left);
			if(node.right != null)
				queue.offer(node.right);
		}
	}	
}

递归方法
class Solution {
    List<List<Integer>> levels = new ArrayList<List<Integer>>();
    public void helper(TreeNode node, int level) {
        if(node == null) return;
        // start the current level
        if (levels.size() == level)
            levels.add(new ArrayList<Integer>());

         // fulfil the current level
         levels.get(level).add(node.val);

         // process child nodes for the next level
         helper(node.left, level + 1);
         helper(node.right, level + 1);
    }    
    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) return levels;
        helper(root, 0);
        return levels;
    }
}