二叉树-DFS-BFS-递归-非递归
BFS
BFS一般使用非递归的模式访问相对简单，其递归的模式相当于是非递归模式，按每一层打标签访问的结果。使用list保存每一层的需要访问的节点，可以将代码写成递归形式。
非递归形式
主要思想：从根节点以此访问左右子树，然后将访问到的节点按访问顺序依次存储在队列之中，在队列非空的情况下，一直按照这种方案进行即可完成BFS的非递归访问。
#include <iostream>
#include <vector>
#include <stack>
#include <cmath>
#include <map>
#include <string>
#include <list>
using namespace std;
struct TreeNode{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int vall){
val = vall;
left = NULL;
right = NULL;
}
};
vector<int> BFSNoRecursive(TreeNode *root){
vector<int> ans;
list<TreeNode *> llist;
if(root == NULL){
return ans;
}
else{
llist.push_back(root);
}
while(!llist.empty()){
TreeNode *temp = llist.front();
ans.push_back(temp->val);
if(temp->left){
llist.push_back(temp->left);
}
if(temp->right){
llist.push_back(temp->right);
}
llist.pop_front();
}
return ans;
}
int main(int argc, const char * argv[]) {
TreeNode *r1 = new TreeNode(1);
TreeNode *r2 = new TreeNode(2);
TreeNode *r3 = new TreeNode(3);
TreeNode *r4 = new TreeNode(4);
TreeNode *r5 = new TreeNode(5);
TreeNode *r6 = new TreeNode(6);
TreeNode *r7 = new TreeNode(7);
r1->left = r2;
r1->right = r3;
r2->left = r4;
r2->right = r5;
r3->left = r6;
r6->right = r7;
vector<int> ans = BFSNoRecursive(r1);
for(int i = 0; i < ans.size(); i++){
cout << ans[i] << " ";
}
return 0;
}
递归形式
主要思想：用一个二维数组记录下每一层的指针，这个过程可以用递归来实现，其实在记录过程中，采用的是dfs的套路。记录完成之后，按层访问每一个节点即可。
#include <iostream>
#include <vector>
#include <stack>
#include <cmath>
#include <map>
#include <string>
#include <list>
using namespace std;
struct TreeNode{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int vall){
val = vall;
left = NULL;
right = NULL;
}
};
void bfs(TreeNode *root, int level, vector<vector<TreeNode *> >& llist){
if(root == NULL){
return;
}
if(level >= llist.size()){
vector<TreeNode *> listTemp;
listTemp.push_back(root);
llist.push_back(listTemp);
}
else{
llist[level].push_back(root);
}
bfs(root->left, level+1, llist);
bfs(root->right, level+1, llist);
}
vector<int> BFSRecursive(TreeNode *root){
vector<int> ans;
vector<vector<TreeNode *> > llist;
if(root == NULL){
return ans;
}
else{
bfs(root, 0, llist);
}
for(int i = 0; i < llist.size(); i++){
for(int j = 0; j < llist[i].size(); j++){
ans.push_back(llist[i][j]->val);
}
}
return ans;
}
int main(int argc, const char * argv[]) {
TreeNode *r1 = new TreeNode(1);
TreeNode *r2 = new TreeNode(2);
TreeNode *r3 = new TreeNode(3);
TreeNode *r4 = new TreeNode(4);
TreeNode *r5 = new TreeNode(5);
TreeNode *r6 = new TreeNode(6);
TreeNode *r7 = new TreeNode(7);
r1->left = r2;
r1->right = r3;
r2->left = r4;
r2->right = r5;
r3->left = r6;
r6->right = r7;
vector<int> ans = BFSRecursive(r1);
for(int i = 0; i < ans.size(); i++){
cout << ans[i] << " ";
}
return 0;
}
DFS
DFS的访问模式总共是分为三种，即先序，中序，后序。其中，先中后是相对于根节点而言的。
先序：根，左，右
中序：左，根，右
后序：左，右，根
这三种方式都有递归和非递归两种实现方法，比较简洁理想的是采用递归方式，非递归方式需要借助栈进行实现。
递归形式
只在递归的顺序上有很小的调整！！
先序
#include <iostream>
#include <vector>
#include <stack>
#include <cmath>
#include <map>
#include <string>
#include <list>
using namespace std;
struct TreeNode{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int vall){
val = vall;
left = NULL;
right = NULL;
}
};
void DFSRecursive(TreeNode *root, vector<int>& ans){
if(root == NULL){
return;
}
ans.push_back(root->val);
DFSRecursive(root->left, ans);
DFSRecursive(root->right, ans);
}
int main(int argc, const char * argv[]) {
TreeNode *r1 = new TreeNode(1);
TreeNode *r2 = new TreeNode(2);
TreeNode *r3 = new TreeNode(3);
TreeNode *r4 = new TreeNode(4);
TreeNode *r5 = new TreeNode(5);
TreeNode *r6 = new TreeNode(6);
TreeNode *r7 = new TreeNode(7);
r1->left = r2;
r1->right = r3;
r2->left = r4;
r2->right = r5;
r3->left = r6;
r6->right = r7;
vector<int> ans;
DFSRecursive(r1, ans);
for(int i = 0; i < ans.size(); i++){
cout << ans[i] << " ";
}
return 0;
}
中序
#include <iostream>
#include <vector>
#include <stack>
#include <cmath>
#include <map>
#include <string>
#include <list>
using namespace std;
struct TreeNode{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int vall){
val = vall;
left = NULL;
right = NULL;
}
};
void DFSRecursive(TreeNode *root, vector<int>& ans){
if(root == NULL){
return;
}
DFSRecursive(root->left, ans);
ans.push_back(root->val);
DFSRecursive(root->right, ans);
}
int main(int argc, const char * argv[]) {
TreeNode *r1 = new TreeNode(1);
TreeNode *r2 = new TreeNode(2);
TreeNode *r3 = new TreeNode(3);
TreeNode *r4 = new TreeNode(4);
TreeNode *r5 = new TreeNode(5);
TreeNode *r6 = new TreeNode(6);
TreeNode *r7 = new TreeNode(7);
r1->left = r2;
r1->right = r3;
r2->left = r4;
r2->right = r5;
r3->left = r6;
r6->right = r7;
vector<int> ans;
DFSRecursive(r1, ans);
for(int i = 0; i < ans.size(); i++){
cout << ans[i] << " ";
}
return 0;
}
后序
#include <iostream>
#include <vector>
#include <stack>
#include <cmath>
#include <map>
#include <string>
#include <list>
using namespace std;
struct TreeNode{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int vall){
val = vall;
left = NULL;
right = NULL;
}
};
void DFSRecursive(TreeNode *root, vector<int>& ans){
if(root == NULL){
return;
}
DFSRecursive(root->left, ans);
DFSRecursive(root->right, ans);
ans.push_back(root->val);
}
int main(int argc, const char * argv[]) {
TreeNode *r1 = new TreeNode(1);
TreeNode *r2 = new TreeNode(2);
TreeNode *r3 = new TreeNode(3);
TreeNode *r4 = new TreeNode(4);
TreeNode *r5 = new TreeNode(5);
TreeNode *r6 = new TreeNode(6);
TreeNode *r7 = new TreeNode(7);
r1->left = r2;
r1->right = r3;
r2->left = r4;
r2->right = r5;
r3->left = r6;
r6->right = r7;
vector<int> ans;
DFSRecursive(r1, ans);
for(int i = 0; i < ans.size(); i++){
cout << ans[i] << " ";
}
return 0;
}
非递归形式
需要借助于栈结构，在向下查询的过程中，访问不到的节点先存储在栈中
先序
1、从根节点一路向左访问，并将访问到的每一个节点的指针存储在栈中。
2、由于是先序遍历，则在一路向左访问过程中，首先将每个根节点数据存储在ans中。
3、访问到最左以后，使用栈模拟回溯过程，依次对栈中每一个节点的右子树进行先序遍历。
#include <iostream>
#include <vector>
#include <stack>
#include <cmath>
#include <map>
#include <string>
#include <list>
using namespace std;
struct TreeNode{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int vall){
val = vall;
left = NULL;
right = NULL;
}
};
vector<int> DFSNoRecursive(TreeNode *root){
vector<int> ans;
if(root == NULL){
return ans;
}
stack<TreeNode*> s;
TreeNode *temp = root;
while(temp != NULL || !s.empty()){
while(temp != NULL){
ans.push_back(temp->val);
s.push(temp);
temp = temp->left;
}
if(!s.empty()){
temp = s.top();
s.pop();
temp = temp->right;
}
}
return ans;
}
int main(int argc, const char * argv[]) {
TreeNode *r1 = new TreeNode(1);
TreeNode *r2 = new TreeNode(2);
TreeNode *r3 = new TreeNode(3);
TreeNode *r4 = new TreeNode(4);
TreeNode *r5 = new TreeNode(5);
TreeNode *r6 = new TreeNode(6);
TreeNode *r7 = new TreeNode(7);
r1->left = r2;
r1->right = r3;
r2->left = r4;
r2->right = r5;
r3->left = r6;
r6->right = r7;
vector<int> ans = DFSNoRecursive(r1);
for(int i = 0; i < ans.size(); i++){
cout << ans[i] << " ";
}
return 0;
}
中序
基本和先序一致
1、从根节点一路向左访问，并将访问到的每一个节点的指针存储在栈中。
2、由于是中序遍历，则在一路向左访问过程中，不能将每个根节点数据存储在ans中，在回溯时，将根节点数据存储在ans中。
3、访问到最左以后，使用栈模拟回溯过程，依次对栈中每一个节点的右子树进行先序遍历。
#include <iostream>
#include <vector>
#include <stack>
#include <cmath>
#include <map>
#include <string>
#include <list>
using namespace std;
struct TreeNode{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int vall){
val = vall;
left = NULL;
right = NULL;
}
};
vector<int> DFSNoRecursive(TreeNode *root){
vector<int> ans;
if(root == NULL){
return ans;
}
stack<TreeNode*> s;
TreeNode *temp = root;
while(temp != NULL || !s.empty()){
while(temp != NULL){
s.push(temp);
temp = temp->left;
}
if(!s.empty()){
temp = s.top();
s.pop();
ans.push_back(temp->val);
temp = temp->right;
}
}
return ans;
}
int main(int argc, const char * argv[]) {
TreeNode *r1 = new TreeNode(1);
TreeNode *r2 = new TreeNode(2);
TreeNode *r3 = new TreeNode(3);
TreeNode *r4 = new TreeNode(4);
TreeNode *r5 = new TreeNode(5);
TreeNode *r6 = new TreeNode(6);
TreeNode *r7 = new TreeNode(7);
r1->left = r2;
r1->right = r3;
r2->left = r4;
r2->right = r5;
r3->left = r6;
r6->right = r7;
vector<int> ans = DFSNoRecursive(r1);
for(int i = 0; i < ans.size(); i++){
cout << ans[i] << " ";
}
return 0;
}
后序
先序和中序基本是一个套路，后序相对复杂一些，需要单独对当前访问树结构的根节点进行记录。相当于记录右子树的访问情况。因为此时，必须确定将左，右子树全部访问完，才访问根节点。
1、从根节点一路向左访问，并将访问到的每一个节点的指针存储在栈中。
2、在回溯过程中，首先将左子树的值记录下来，然后记录当前的根，然后判断右子树是否已经访问，如果未访问，则先访问右子树，最后再记录根节点的值。
#include <iostream>
#include <vector>
#include <stack>
#include <cmath>
#include <map>
#include <string>
#include <list>
using namespace std;
struct TreeNode{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int vall){
val = vall;
left = NULL;
right = NULL;
}
};
vector<int> DFSNoRecursive(TreeNode *root){
vector<int> ans;
if(root == NULL){
return ans;
}
stack<TreeNode*> s;
TreeNode *temp = root;
TreeNode *last = NULL;
while(temp != NULL || !s.empty()){
while(temp != NULL){
s.push(temp);
temp = temp->left;
}
if(!s.empty()){
temp = s.top();
if(temp->right == NULL || temp->right == last){
ans.push_back(temp->val);
s.pop();
last = temp;
temp = NULL;
}
else{
temp = temp->right;
}
}
}
return ans;
}
int main(int argc, const char * argv[]) {
TreeNode *r1 = new TreeNode(1);
TreeNode *r2 = new TreeNode(2);
TreeNode *r3 = new TreeNode(3);
TreeNode *r4 = new TreeNode(4);
TreeNode *r5 = new TreeNode(5);
TreeNode *r6 = new TreeNode(6);
TreeNode *r7 = new TreeNode(7);
r1->left = r2;
r1->right = r3;
r2->left = r4;
r2->right = r5;
r3->left = r6;
r6->right = r7;
vector<int> ans = DFSNoRecursive(r1);
for(int i = 0; i < ans.size(); i++){
cout << ans[i] << " ";
}
return 0;
}
1176
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
