常见算法 - 二叉树:二叉树的层次遍历&倒层次遍历

二叉树的层次遍历(leetcode102)：

1.非递归遍历，借助队列实现，队列多用于广度遍历:

public class L102BinaryTreeLevelOrderTraversal {

	public static List<List<Integer>> levelOrder(TreeNode root) {
        
		List<List<Integer>> res = new LinkedList<List<Integer>>();
		if(root == null){
			return res;
		}
		LinkedList<Tree> ll = new LinkedList<Tree>();
		ll.add(new Tree(root, 1));
		while(!ll.isEmpty()){
			Tree tree = ll.pop();
			TreeNode curr = tree.treeNode;
			int level = tree.level;
			if(res.size() < level){
				List<Integer> list = new LinkedList<Integer>();
				res.add(list);
			}
			res.get(level-1).add(curr.val);
			if(curr.left !=null ){
				ll.add(new Tree(curr.left, level+1));
			}
			if(curr.right !=null ){
				ll.add(new Tree(curr.right, level+1));
			}
		}
		return res;
    }
}

class Tree{
	TreeNode treeNode;
	Integer level;
	public Tree(TreeNode treeNode, Integer level) {
		super();
		this.treeNode = treeNode;
		this.level = level;
	}
	
}

2.递归遍历，思路和非递归一样

class Solution {
    public static List<List<Integer>> levelOrder(TreeNode root) {
     
		List<List<Integer>> res = new LinkedList<List<Integer>>();
        res = levelOrderHelper(root,res,0);
		return res;
    }
    
    public static List<List<Integer>> levelOrderHelper(TreeNode node,List<List<Integer>> list,int level){
        
        List<List<Integer>> res = list;
        if(node == null){
            return res;
        }
        if( level >= list.size()){
            res.add(new LinkedList<Integer>());
        }
        res.get(level).add(node.val);
        if(node.left != null){
            levelOrderHelper(node.left,res,level+1);
        }
        if(node.right != null){
            levelOrderHelper(node.right,res,level+1);
        }
        return res;
    }
}

二叉树的倒的层次遍历(leetcode107)

思路：简单的方法就是，将上面的层次遍历的答案倒序放入另外一个List中，就变成倒叙层次遍历了。

          同样道理，利用上面的递归遍历，先递归再存值，存放时相应值存放在list.size-level-1层中就可以了

public class Solution {

        public List<List<Integer>> levelOrderBottom(TreeNode root) {
            List<List<Integer>> res = new LinkedList<List<Integer>>();
            levelOrderHelper(res, root, 0);
            return res;
        }
        
        public void levelOrderHelper(List<List<Integer>> list, TreeNode root, int level) {
            if(root == null) return;
            if(level >= list.size()) {
                list.add(0, new LinkedList<Integer>());
            }
            levelOrderHelper(list, root.left, level+1);
            levelOrderHelper(list, root.right, level+1);
            list.get(list.size()-level-1).add(root.val);
        }
    }