1. 题目描述
给定一课二叉树(如下),分别完成从上往下层级遍历、从下往上层级遍历、Z字形从上往下层级遍历:
4
/ \
2 6
/ \ / \
1 3 5 7
输出结果如下:
第一种情况:从上往下层级遍历:
[
[4],
[2,6],
[1,3,5,7]
]
第二种情况:从下往上层级遍历:
[
[1,3,5,7],
[2,6],
[4]
]
第三种情况:Z字形从上往下层级遍历:
[
[4],
[6,2],
[1,3,5,7]
]
2. 二叉树的数据结构:
struct TreeNode
{
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int v = 0, TreeNode *l = NULL, TreeNode *r = NULL):val(v),left(l),right(r){}
};
3. 从上往下层级遍历
3.1 思路分析
《剑指offer》中有个题目和这个很类似,其只是层次遍历二叉树,没有要求把每层的节点单独放在一起的。其做法是:每次打印一个节点的时候,如果该结点有子结点,则把该结点的子结点放到一个队列的尾部;接下来到队列的头部取出最早进入队列的结点;重复前面的打印操作,直到队列中所有的结点都被打印出来为止。
但是本题稍微复杂一点的是,我们要把各个层的数分开,存到一个二维向量里面,但大体思路还是基本相同的。首先,建立一个队列,然后先把根节点放进去,接着找根节点的左右两个子节点,然后去掉根节点,此时队列里的元素就是下一层的所有节点,用一个for循环遍历它们,然后存到一个一维向量里,遍历完之后再把这个一维向量存到二维向量里,以此类推,可以完成层序遍历。
3.2 方法1:迭代法
vector<vector<int>> levelOrder(TreeNode *root)
{
vector<vector<int>> result;
if(root == NULL)
{
return result;
}
queue<TreeNode *> q;
q.push(root);
while(!q.empty())
{
vector<int> oneLevel;
int size = q.size();
for(int i = 0; i < size; i++)
{
TreeNode *node = q.front();
q.pop();
oneLevel.push_back(node->val);
if(node->left != NULL)
{
q.push(node->left);
}
if(node->right != NULL)
{
q.push(node->right);
}
}
result.push_back(oneLevel);
}
return result;
}
3.3 方法2:递归法
递归的核心在于:需要一个二维数组,和一个变量level,当level递归到上一层的个数时,我们新建一个空层,继续往里面加数字。
vector<vector<int>> levelOrder(TreeNode *root)
{
vector<vector<int>> result;
traverse(root, 0, result);
return result;
}
void traverse(TreeNode *root, size_t level, vector<vector<int>> &result)
{
if(root == NULL)
{
return;
}
if(result.size() == level)
{
result.push_back(vector<int>());
}
result[level].push_back(root->val);
if(root->left != NULL)
{
traverse(root->left, level+1, result);
}
if(root->right != NULL)
{
traverse(root->right, level+1, result);
}
}
4. 从下往上层级遍历
4.1 思路分析
这种情况与上面的情况一致,区别在于最后的输出顺序不一样
4.2 方法1:迭代法
vector<vector<int>> levelOrderBottom(TreeNode* root)
{
vector<vector<int> > result;
if(root == NULL)
{
return result;
}
queue<TreeNode *> q;
q.push(root);
while(!q.empty())
{
vector<int> oneLevel;
int size = q.size();
for(int i = 0; i < size; i++)
{
TreeNode *node = q.front();
q.pop();
oneLevel.push_back(node->val);
if(node->left != NULL)
{
q.push(node->left);
}
if(node->right != NULL)
{
q.push(node->right);
}
}
result.insert(result.begin(), oneLevel);
}
return result;
}
4.3 方法2:递归法
vector<vector<int>> levelOrderBottom(TreeNode* root)
{
vector<vector<int> > result;
levelorder(root, 0, result);
return vector<vector<int> > (result.rbegin(), result.rend());
}
void levelorder(TreeNode *root, int level, vector<vector<int> > &result)
{
if (root == NULL)
{
return;
}
if (result.size() == level)
{
result.push_back({});
}
result[level].push_back(root->val);
if (root->left)
{
levelorder(root->left, level + 1, result);
}
if (root->right)
{
levelorder(root->right, level + 1, result);
}
}
5. Z字形从上往下层级遍历
5.1 思路分析
这道题是之前的层级遍历的变形,不同之处在于一行是从左到右遍历,下一行是从右往左遍历,交叉往返的之字形的层序遍历。根据其特点我们用到栈的后进先出的特点,这道题我们维护两个栈,相邻两行分别存到两个栈中,进栈的顺序也不相同,一个栈是先进左子结点然后右子节点,另一个栈是先进右子节点然后左子结点,这样出栈的顺序就是我们想要的之字形了。
5.2 方法1:迭代法(双栈实现)
vector<vector<int>> zigzagLevelOrder(TreeNode *root)
{
vector<vector<int>> result;
if(root == NULL)
{
return result;
}
stack<TreeNode *> s1;
stack<TreeNode *> s2;
s1.push(root);
vector<int> out; //存放每一行的输出
while(!s1.empty() || !s2.empty())
{
while(!s1.empty())
{
TreeNode *pCur = s1.top();
s1.pop();
out.push_back(pCur->val);
if(pCur->left != NULL)
{
s2.push(pCur->left);
}
if(pCur->right != NULL)
{
s2.push(pCur->right);
}
}
if(!out.empty())
{
result.push_back(out);
}
out.clear();
while(!s2.empty())
{
TreeNode *pCur = s2.top();
s2.pop();
out.push_back(pCur->val);
if(pCur->right != NULL)
{
s1.push(pCur->right);
}
if(pCur->left)
{
s1.push(pCur->left);
}
}
if(!out.empty())
{
result.push_back(out);
}
out.clear();
}
return result;
}
5.3 方法2:迭代法(队列实现)
vector<vector<int>> zigzagLevelOrder2(TreeNode *root) //队列实现Z字型层级遍历
{
vector<vector<int>> result;
if(root == NULL)
{
return result;
}
queue<TreeNode *> q;
bool left_to_right = true; //记录是从左到右还是从右到左,每一层结束就翻转一下
vector<int> out; //记录每一层的数据
q.push(root);
q.push(nullptr);
while(!q.empty())
{
TreeNode *pCur = q.front();
q.pop();
if(pCur != NULL)
{
out.push_back(pCur->val);
if(pCur->left != NULL)
q.push(pCur->left);
if(pCur->right != NULL)
q.push(pCur->right);
}
else
{
if(left_to_right)
{
result.push_back(out);
}
else
{
reverse(out.begin(), out.end());
result.push_back(out);
}
out.clear();
left_to_right = !left_to_right ;
if(q.size() > 0)
q.push(nullptr);
}
}
return result;
}
5.4 方法3:递归法(队列实现)
vector<vector<int> > zigzagLevelOrder3(TreeNode *root)
vector<vector<int>> result;
recursive (root, 1, result, true);
return result;
}
void recursive(TreeNode *root, size_t level, vector<vector<int>> &result, bool left_to_right)
{
if (!root)
return;
if (level > result.size())
result.push_back(vector<int>());
if (left_to_right)
result[level-1].push_back(root->val);
else
result[level-1].insert(result[level-1].begin(), root->val);
recursive (root->left, level+1, result, !left_to_right);
recursive (root->right, level+1, result, !left_to_right);
}
ps: 完整测试代码见我的代码片:https://code.csdn.net/snippets/1762076
参考文章:
1、http://www.cnblogs.com/grandyang/p/4051321.html
2、http://www.cnblogs.com/grandyang/p/4051326.html
3、http://www.cnblogs.com/grandyang/p/4297009.html
4、Acm之家: Binary Tree Zigzag Level Order Traversal
Note: 以上几篇文章对我写作本文起了很大作用,在此非常感谢。