从上到下打印二叉树系列（三道题）python+java

从上到下打印二叉树，可以看出是二叉树的广度优先搜索（bfs），bfs借助队列进行实现。

java代码如下所示：

class Solution {
    public int[] levelOrder(TreeNode root){
        if(root == null) return new int[0];

        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        ArrayList<Integer> ans = new ArrayList<>();
        queue.add(root);

        while(!queue.isEmpty()){
            TreeNode node = queue.poll();

            if(node.left != null){
                queue.add(node.left);
            }

            if(node.right != null){
                queue.add(node.right);
            }

            ans.add(node.val);

        }

        int[] res = new int[ans.size()];
        for(int i = 0; i < ans.size(); i++){
            res[i] = ans.get(i);
        }

        return res;

    }

}

要求每层打印到一行，因此在每轮出队的时候，记录队列的长度，把当前层的元素全部出队之后，再进行下一轮的遍历；
代码如下：

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {

        if(root == null){
            return new ArrayList<>();
        }

        Queue<TreeNode> queue = new LinkedList<>();
//        ArrayList<Integer> list = new ArrayList<>();
        List<List<Integer>> res = new ArrayList<>();

        if(root != null) queue.add(root);

        while(!queue.isEmpty()){
            ArrayList<Integer> list = new ArrayList<>();


            int n = queue.size();


            while(n != 0){
                TreeNode node = queue.poll();
                list.add(node.val);

                if(node.left != null){
                    queue.add(node.left);
                }
                if(node.right != null){
                    queue.add(node.right);
                }

                n--;

            }
            res.add(list);
            
        }

        return res;

    }
}

实现分奇偶层进行打印，建立一个临时的数组用于存储打印的结果，在java中用LinkedList进行存储。
代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {

        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();

        if(root != null) queue.add(root);
        while(!queue.isEmpty()){
            LinkedList<Integer> tmp = new LinkedList<>();
            for(int i = queue.size(); i > 0; i--){
                TreeNode node = queue.poll();
                if(res.size() % 2 == 0){
                    tmp.addLast(node.val);
                }
                else{
                    tmp.addFirst(node.val);
                }

                if(node.left != null){
                    queue.add(node.left);

                }

                if(node.right != null){
                    queue.add(node.right);
                }
            }

            res.add(tmp);

        }
        return res;





    }
}

class Solution:
    def levelOrder(self, root):

    	if not root:
    		return []

    	res, deque = [], collections.deque([root])

    	#利用结果列表来计算奇数还是偶数层

    	while deque:

    		tmp = collections.deque()

    		for _ in range(len(deque)):

    			node = deque.popleft()

    			if len(res) % 2:
    				tmp.appendleft(node.val)

    			else:
    				tmp.append(node.val)

    			if node.left:
    				deque.append(node.left)
    			if node.right:
    				deque.append(node.right)

    		res.append(list(tmp))

    	return res