|
目录
1.简介
2.二叉树的深度优先遍历
2.1 二叉树的前序遍历
2.2 二叉树的中序遍历
2.3 二叉树的后序遍历
3. 二叉树的广度优先搜索
3.1 二叉树广度优先搜索
3.2 二叉树的层序遍历
3.3 二叉树自底向上层序遍历
3.4 二叉树的锯齿形层序遍历
? ? ????????二叉树是一种很常用的基本数据结构，它可以看做一种特殊的图(一个节点只有一个入度和最多两个出度)，因此二叉树的的遍历要比图简单很多，学好二叉树也能较容易掌握图的遍历。
1.简介
? ? ? ? 我们知道树/图的遍历分为深度优先搜索(DFS)和广度优先搜索(BFS)。一般来说深度优先搜索的特点决定了深度优先搜索依赖于栈的实现，而广度优先搜索的实现依赖于队列的实现。
? ? ? ? 二叉树的深度优先搜索根据遍历根节点的顺序分为前序遍历、中序遍历和后序遍历。而二叉树的广度优先搜索基本上等价于层序遍历。
2.二叉树的深度优先遍历
? ? ? ? 深度优先搜索一般依赖于栈的实现，通过递归可以很容易的写出二叉树的前序、中序和后序遍历。似乎代码中也没有显示使用栈这个数据结构，那是因为递归调用隐式地使用了系统栈。编写非递归的深度优先遍历就必须自己使用栈来实现了。下面我们看看二叉树各种深度优先遍历的递归和非递归实现。
2.1 二叉树的前序遍历
LeetCode第144题144. 二叉树的前序遍历
? ? ? ?递归实现非常简单，先跟节点，然后递归遍历左子树和右子树：
void traversal(TreeNode* root, vector<int>& res) {
if(root == nullptr)
return;
res.emplace_back(root->val);
traversal(root->left, res);
traversal(root->right, res);
}
vector<int> preorderTraversal(TreeNode* root) {
vector<int> res;
traversal(root, res);
return res;
}
? ? ? ? 非递归实现使用栈来保存遍历过的节点，不断入栈出栈直到栈空为止。 非递归实现与递归实现不同，遍历根节点后要先遍历右子树再遍历左子树（因栈的后进先出特性）：
vector<int> preorderTraversal(TreeNode* root) {
vector<int> res;
if(root == nullptr)
return res;
stack<TreeNode*> st;
st.push(root);
while (!st.empty()) {
auto node = st.top();
res.push_back(node->val);
st.pop();
if(node->right != nullptr)
st.push(node->right);
if(node->left != nullptr)
st.push(node->left);
}
return res;
}
2.2 二叉树的中序遍历
LeetCode 94题?94. 二叉树的中序遍历
递归实现：
void travesal(TreeNode* root, vector<int>& res){
if(!root)
return;
travesal(root->left,res);
res.push_back(root->val);
travesal(root->right, res);
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int> res;
travesal(root, res);
return res
}
非递归实现，使用栈保存遍历过的节点，先找到最左节点然后依次出栈遍历节点对应的右子节点：
vector<int> inorderTraversal(TreeNode* root) {
vector<int> res;
stack<TreeNode*> st;
while (root != nullptr || !st.empty()) {
while (root != nullptr) {
st.push(root);
root = root->left;
}
root = st.top();
st.pop();
res.push_back(root->val);
root = root->right;
}
return res;
}
2.3 二叉树的后序遍历
LeetCode 145题?145. 二叉树的后序遍历? ?
递归实现：
void traversal(TreeNode* root, vector<int>&res){
if(root == nullptr)
return;
traversal(root->left, res);
traversal(root->right, res);
res.push_back(root->val);
}
vector<int> postorderTraversal(TreeNode* root) {
vector<int> res;
traversal(root, res);
return res;
}
非递归实现，使用栈保存遍历过的节点，先找到最右节点然后依次出栈遍历节点对应的左子节点，最后需要反转遍历结果：
vector<int> postorderTraversal(TreeNode* root) {
vector<int> res;
if(root == nullptr)
return res;
stack<TreeNode*> st;
TreeNode* prev = nullptr;
while (!st.empty() || root != nullptr) {
while(root != nullptr) {
res.push_back(root->val);
st.push(root);
root = root->right;
}
root = st.top()->left;
st.pop();
}
reverse(res.begin(), res.end());
return res;
}
3. 二叉树的广度优先搜索
? ? ? ? 二叉树的广度优先搜索类似于层序遍历：遍历跟节点，遍历左子节点和右子节点，然后遍历左子节点和它的左右子节点以及右子节点和它的左右子节点。广度优先搜索严格按照遍历的先后循序遍历节点，符合队列先进先出(FIFO)的特点，适合使用队列来实现。
3.1 二叉树广度优先搜索
? ? ? ? 二叉树单纯的广度优先搜索很简单，不断的入队出队直到队列为空就遍历结束了。
void bfs(TreeNode* root) {
if(!root)
return;
queue<TreeNode*> que;
que.push(root);
while(!que.empty()){
auto node = que.front();
que.pop();
cout << node->val << endl;
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
return res;
}
下面我们看几道LeetCode层序遍历相关编程题。
3.2 二叉树的层序遍历
? ? ? ? ?LeetCode 102题?102. 二叉树的层序遍历
? ? ? ? 与上面的算法不同，这道题要求分层返回遍历结果，所以需要一点技巧：跟节点入队后加入一个空节点做哨兵，出队的时候发现是空节点就知道一层遍历结束了，保存本层结果继续加入空节点做哨兵。
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> res;
if(!root)
return res;
queue<TreeNode*> que;
que.push(root);
que.push(nullptr);
vector<int> temp;
while(!que.empty()){
auto node = que.front();
que.pop();
if(node){
temp.push_back(node->val);
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}else if(!temp.empty()){
res.push_back(temp);
temp.clear();
que.push(nullptr);
}
}
return res;
}
3.3 二叉树自底向上层序遍历
LeetCode 107题?107. 二叉树的层序遍历 II
与上一节层序遍历基本相同，得到自顶向下的层序遍历结果后，逆置一下数组结果就可以了：
vector<vector<int>> levelOrderBottom(TreeNode* root) {
vector<vector<int>> res;
if(root == nullptr)
return res;
queue<TreeNode*> que;
que.push(root);
que.push(nullptr);
vector<int> temp;
while(!que.empty()){
auto node = que.front();
que.pop();
if(node){
temp.push_back(node->val);
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}else if(!temp.empty()){
res.push_back(temp);
temp.clear();
que.push(nullptr);
}
}
reverse(res.begin(), res.end());
return res;
}
3.4 二叉树的锯齿形层序遍历
LeetCode 103题?103. 二叉树的锯齿形层序遍历
与层序遍历不同的是，题目要求一层正序遍历一层逆序遍历。只需要在层序遍历基础上加上一个标志，需要逆序时逆置一下该层遍历结果就可以了。
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int>> res;
if(!root)
return res;
queue<TreeNode*> que;
que.push(root);
que.push(nullptr);
vector<int> temp;
bool change = false;
while(!que.empty()){
auto node = que.front();
que.pop();
if(node){
temp.push_back(node->val);
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}else if(!temp.empty()){
if(change)
reverse(temp.begin(), temp.end());
res.push_back(temp);
temp.clear();
que.push(nullptr);
change = !change;
}
}
return res;
}
|