从上到下，从左到右打印二叉树：

 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };

本质是要求广搜，以

二叉树示意图

为例，结果应当是1,2,3,4,5
过程如下：
初始队列【1】
1输出，1的两个儿子2和3加入；【2，3】
2出队，2的儿子4加入；【3，4】
3出队，3的儿子5加入；【4，5】
4出队，5出队，结束。

C++的队列通常是用queue实现；

    vector<int> levelOrder(TreeNode* root) {
        vector<int> res={};
        if (root==NULL)
            return res;
        queue<TreeNode*>que;
        que.push(root);
        while(!que.empty()){
            TreeNode* x=que.front();
            if(x->left)
                que.push(x->left);
            if(x->right)
            que.push(x->right);
            res.push_back(x->val);
            que.pop();
        }
        return res;
    }

go语言的切片实现

func levelOrder(root *TreeNode) []int {
    var res [] int
    if (root==nil){
        return res
    }
    que:= []*TreeNode{root}
    cnt:=0
    for(cnt<len(que)){
        x:=que[cnt]
        que[cnt]=nil
        res=append(res,x.Val)
        if(x.Left!=nil){
            que=append(que,x.Left)
        }
        if(x.Right!=nil){
            que=append(que,x.Right)
        }
        cnt++
    }
    return res
}

go语言的list容器实现：

func levelOrder(root *TreeNode) []int {
    var res [] int
    if (root==nil){
        return res
    }
    que:=list.New()
    que.PushBack(root)
    for(que.Len()!=0){
        x:=que.Front().Value.(*TreeNode)
        res=append(res,x.Val)
        if(x.Left!=nil){
            que.PushBack(x.Left)
        }
        if(x.Right!=nil){
            que.PushBack(x.Right)
        }
        que.Remove(que.Front())
    }
    return res
}