4.4-按行输出二叉树（same in LeetCode）

Given a binary search tree, design an algorithm which creates a linked list of all the nodes at each depth (eg, if you have a tree with depth D, you’ll have D linked lists).

LeetCode:https://oj.leetcode.com/submissions/detail/3391867/

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
vector<vector<int> > levelOrder_2vec(TreeNode *root)
{
    vector<vector<int> > ans;
    vector<int> level;
    vector<TreeNode *> cur,next;
    cur.push_back(root);

    while(!cur.empty())
    {
        level.clear();
        next.clear();
        for(int i=0;i<cur.size();i++)
        {
            level.push_back(cur[i]->val);

            if(cur[i]->left)
              next.push_back(cur[i]->left);
            if(cur[i]->right)
              next.push_back(cur[i]->right);
        }
        ans.push_back(level);
        cur=next;
    }

    return ans;
}
vector<vector<int> > levelOrder_queue(TreeNode *root)
{
    vector<vector<int> > ans;
    vector<int> level;
    queue<TreeNode *> myqueue;
    myqueue.push(root);
    int cur_count=1;

    while(!myqueue.empty())
    {
        level.clear();
        int next_count=0;
        for(int i=0;i<cur_count;i++)
        {
            TreeNode * tmp = myqueue.front();
            level.push_back(tmp->val);
            myqueue.pop();

            if(tmp->left)
             {
                 myqueue.push(tmp->left);
                 next_count++;
             }
            if(tmp->right)
             {
                 myqueue.push(tmp->right);
                 next_count++;
             }
        }
        ans.push_back(level);
        cur_count = next_count;
    }

    return ans;
}
int main()
{
    TreeNode * a = new TreeNode(1);
    TreeNode * b = new TreeNode(2);
    TreeNode * c = new TreeNode(3);
    TreeNode * d = new TreeNode(4);
    TreeNode * e = new TreeNode(5);
    TreeNode * f = new TreeNode(6);
    a->left=b;
    a->right=c;
    b->right=d;
    c->left=e;
    c->right=f;

    vector<vector<int> > ans = levelOrder_2vec(a);
    for(int i=0; i<ans.size(); i++)
    {
        for(int j=0; j<ans[i].size(); j++)
            cout << ans[i][j];
        cout << endl;
    }
    cout <<"---------------------" <<endl;
    vector<vector<int> > ans2 = levelOrder_queue(a);
    for(int i=0; i<ans2.size(); i++)
    {
        for(int j=0; j<ans2[i].size(); j++)
            cout << ans2[i][j];
        cout << endl;
    }
    return 0;
}