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]
]
思路：
方法1：（层次遍历、BFS）与普通层次遍历稍微不一样的地方就是，需要分出每一层的结点数据来。
如果提前知道每一层数据的个数len，那么只需要循环len次即可取出这一层的数据。那么刚好保持队列内一直为同一层的数据即可。
（两种在vector<vector<int>> ans 添加元素的方法）
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> ans;
//vector<int> anstmp;
if(root==NULL) return ans;
queue<TreeNode*> q;
int index=0;
q.push(root);
int len=0;
while(!q.empty())
{
len=q.size();
ans.push_back(vector<int>());
for(int i=0;i<len;i++)
{
TreeNode* now=q.front();
//anstmp.push_back(now->val);
ans[index].push_back(now->val);
q.pop();
if(now->left) q.push(now->left);
if(now->right) q.push(now->right);
}
//ans.push_back(anstmp);
//anstmp.clear();
index++;
}
return ans;
}
};
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> ans;
vector<int> anstmp;
if(root==NULL) return ans;
queue<TreeNode*> q;
//int index=0;
q.push(root);
int len=0;
while(!q.empty())
{
len=q.size();
for(int i=0;i<len;i++)
{
TreeNode* now=q.front();
anstmp.push_back(now->val);
//ans[index].push_back(now->val);
q.pop();
if(now->left) q.push(now->left);
if(now->right) q.push(now->right);
}
ans.push_back(anstmp);
anstmp.clear();
//index++;
}
return ans;
}
};
方法2：dfs利用树深度添加结果，每次到下一层depth+1
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> ans;
if(root==NULL) return ans;
dfs(ans,root,0);
return ans;
}
void dfs(vector<vector<int>> &ans,TreeNode* root ,int depth)
{
if(root==NULL) return ;
if(ans.size()==depth) ans.push_back(vector<int>());
ans[depth].push_back(root->val);
if(root->left) dfs(ans,root->left,depth+1);
if(root->right) dfs(ans,root->right,depth+1);
}
};
103 Binary Tree Zigzag Level Order Traversal（二叉树分层Z字形遍历）
方法1：index%2!=0,reverse(anstmp.rbegin(),anstmp.rend())
class Solution {
public:
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int>> ans;
vector<int> anstmp;
if(root==NULL) return ans;
queue<TreeNode*> q;
int index=0;
q.push(root);
int len=0;
while(!q.empty())
{
len=q.size();
for(int i=0;i<len;i++)
{
TreeNode* now=q.front();
anstmp.push_back(now->val);
//ans[index].push_back(now->val);
q.pop();
if(now->left) q.push(now->left);
if(now->right) q.push(now->right);
}
if(index%2!=0) reverse(anstmp.rbegin(),anstmp.rend());
ans.push_back(anstmp);
anstmp.clear();
index++;
}
return ans;
}
};
方法2：用两个 stack 表示当前s,和下一个nexts,利用栈的先进后出的原则。有一个区别是这里我们需要一层一层的来处理（原来可以按队列插入就可以，因为后进来的元素不会先处理），所以会同时维护新旧两个栈，一个来读取，一个存储下一层结点。总体来说还是一次遍历完成，所以时间复杂度是O(n)，空间复杂度最坏是两层的结点，所以数量级还是O(n)（满二叉树最后一层的结点是n/2个）。
class Solution {
public:
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int>> ans;
vector<int> anstmp;
if(root==NULL) return ans;
stack<TreeNode*> s;
stack<TreeNode*> nexts;
stack<TreeNode*> tmp;
int index=0;
s.push(root);
int len=0;
while(!s.empty())
{
len=s.size();
for(int i=0;i<len;i++)
{
TreeNode* now=s.top();
anstmp.push_back(now->val);
//ans[index].push_back(now->val);
s.pop();
if(index%2==0)
{
if(now->left) nexts.push(now->left);
if(now->right) nexts.push(now->right);
}
else
{
if(now->right) nexts.push(now->right);
if(now->left) nexts.push(now->left);
}
}
//if(index%2!=0) reverse(anstmp.rbegin(),anstmp.rend());
ans.push_back(anstmp);
anstmp.clear();
tmp=nexts;
nexts=s;
s=tmp;
index++;
}
return ans;
}
};