Binary Tree Zigzag Level Order Traversal——关于广度优先的经典面试题

Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).

For example:

Given binary tree

{3,9,20,#,#,15,7}

,

3
/ \
9  20
/  \
15   7

return its zigzag level order traversal as:

[
[3],
[20,9],
[15,7]
]

这道题明显是要用广度优先算法来实现。

需要注意的是：

深度优先算法要用栈来实现，广度优先需要用队列来实现。之前都是用深度优先算法，这是第一次写关于广度优先算法的实例。

PS:写代码时一定要注意复制粘贴所带来的错误·····················

/**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
struct Node{
TreeNode* node;
int level;
Node(){};
Node(TreeNode* root,int lev):node(root),level(lev){};
};
class Solution {
public:
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int>> res;
vector<int> tempRes;
if(root==NULL)
return res;
queue<Node> Que;
Que.push(Node(root,0));
int curLevel=0;
while(!Que.empty())
{
Node front=Que.front();
if(front.node->left!=NULL)
Que.push(Node(front.node->left,front.level+1));
if(front.node->right!=NULL)
Que.push(Node(front.node->right,front.level+1));
if(curLevel==front.level)
{
tempRes.push_back(front.node->val);
}
else
{
if(curLevel%2==1)
reverse(tempRes.begin(),tempRes.end());
res.push_back(tempRes);
tempRes.clear();
curLevel=front.level;
tempRes.push_back(front.node->val);
}
Que.pop();
}
if(curLevel%2==1)
reverse(tempRes.begin(),tempRes.end());
res.push_back(tempRes);
tempRes.clear();
return res;

}
};

　　网上看到另一种解法，没有定义结构体，设置一个标志来表明是从左往右还是从右往左。这里用的是一个枚举类型enum{L,R};每遍历一层，对方向进行一个转变。

/**
* Definition for binary tree
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector<vector<int> > zigzagLevelOrder(TreeNode *root) {
vector<vector<int>>result;
if (!root)
return result;
vector<int>vec;
queue<TreeNode*>q1;
TreeNode *temp = root;
enum Dir{L,R};
Dir dir = L;
q1.push(root);

while (!q1.empty())
{
queue<TreeNode *>q2;
while (!q1.empty())
{
temp = q1.front();
q1.pop();
if (temp->left)
q2.push(temp->left);
if (temp->right)
q2.push(temp->right);
vec.push_back(temp->val);
}
if (dir == R)
{
reverse(vec.begin(), vec.end());
dir = L;
}
else
dir = R;
result.push_back(vec);
vec.clear();
q1 = q2;
}
return result;
}
};