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;
}