Binary Tree Level Order Traversal

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example:
Given binary tree [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

return its level order traversal as:

[
  [3],
  [9,20],
  [15,7]
]

对树进行层次遍历,当然啦，第一想法是递归，

public class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        int depth = 1;
        List<List<Integer>> lst = new ArrayList<List<Integer>>();
        levelOrder(lst,depth,root);
        return lst;
    }
    public void levelOrder(List<List<Integer>> lst,int depth,TreeNode root){
        if(root == null){
            return;
        }else{
            if(lst.size() < depth){
                List<Integer> lsIn = new ArrayList<Integer>();
                lst.add(lsIn);
            }
            List<Integer> ls = lst.get(depth - 1);
            ls.add(root.val);
            if(root.left != null){
                 levelOrder(lst,depth+1,root.left);
            }
            if(root.right != null){
                levelOrder(lst,depth+1,root.right);
            }
           
        }
        
    }
}

战胜了37.78%，效率的确不高。于是我们修改一下代码，利用链表进行操作。

public class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
		int cnt = 0;
		int f = 0;
		int t = 1;
		List<List<Integer>> lsts = new ArrayList<List<Integer>>();
		List<Integer> lst = new ArrayList<Integer>();
		List<TreeNode> nodeList = new ArrayList<TreeNode>();
		nodeList.add(root);
		if(root == null){
			return 	lsts;
		}
		while(t != 0){
            if(f == t){
            	t = cnt;
            	f = 0;
            	cnt = 0;
            	lsts.add(lst);
            	lst = new ArrayList<Integer>();
            }
            else{
            	TreeNode node = nodeList.get(0);
            	if(node != null){
            		f ++;
            		lst.add(node.val);
            	}
            	if(node.left != null){
            		cnt ++;
            		nodeList.add(node.left);
            	}
            	if(node.right != null){
            		cnt ++;
            		nodeList.add(node.right);
            	}
            	nodeList.remove(node);
            }
		}
	    return 	lsts;
    }
}

可是效率真的太低了，只战胜了11.63%，究其原因是不断的删除元素的操作引起的。我们除去删除的操作。每次生成新的链表存储每层的节点。

public List<List<Integer>> levelOrder(TreeNode root) {
		int cnt = 0;
		int f = 0;
		int t = 1;
		List<List<Integer>> lsts = new ArrayList<List<Integer>>();
		List<Integer> lst = new ArrayList<Integer>();
		List<TreeNode> nodeList = new ArrayList<TreeNode>();
		nodeList.add(root);
		if(root == null){
			return 	lsts;
		}
		while(t != 0){
            if(f == t){
            	t = cnt;
            	f = 0;
            	cnt = 0;
            	lsts.add(lst);
            	lst = new ArrayList<Integer>();
            }
            else{
            	TreeNode node = nodeList.get(0);
            	if(node != null){
            		f ++;
            		lst.add(node.val);
            	}
            	if(node.left != null){
            		cnt ++;
            		nodeList.add(node.left);
            	}
            	if(node.right != null){
            		cnt ++;
            		nodeList.add(node.right);
            	}
            	nodeList.remove(0);
            }
		}
	    return 	lsts;
    }

效率还是不高哦，战胜了37.78% 。我们该怎么优化呢？ 于是我们可以利用一个链表进行操作，由下标进行确定每层的节点。

public List<List<Integer>> levelOrder(TreeNode root) {
	int cnt = 0;
		int f = 0;
		int t = 1;
		int index; 
		List<List<Integer>> lsts = new ArrayList<List<Integer>>();
		List<Integer> lst = new ArrayList<Integer>();
		List<TreeNode> nodeList = new ArrayList<TreeNode>();
		nodeList.add(root);
		if(root == null){
			return 	lsts;
		}
		index = 0;
		while(t != 0){
            if(f == t){
            	t = cnt;
            	f = 0;
            	cnt = 0;
            	lsts.add(lst);
            	lst = new ArrayList<Integer>();
            }
            else{
            	TreeNode node = nodeList.get(index ++);
            	if(node != null){
            		f ++;
            		lst.add(node.val);
            	}
            	if(node.left != null){
            		cnt ++;
            		nodeList.add(node.left);
            	}
            	if(node.right != null){
            		cnt ++;
            		nodeList.add(node.right);
            	}
            }
		}
	    return 	lsts;
    }

此次战胜了87.36% 。