二叉树深度优先搜索、广度优先搜索递归及非递归实现

二叉树BFS,DFS遍历及递归与非递归实现

#include<vector>
#include<iostream>
#include<queue>
#include<stack>
using namespace std;
struct Node{
    int v;
    Node *left,*right;
    Node(int v,Node *left=NULL,Node *right=NULL):v(v),left(left),right(right){}
};
void dfs(Node* root,vector<int>& ans)//深度优先非递归实现
{
	if(root==NULL) return;
	Node* u=root;
	stack<Node*> Stack;
	Stack.push(u);
	while (!Stack.empty()){
		Node *node=Stack.top();
		ans.push_back(node->v);
		Stack.pop();
		if(node->right){
			Stack.push(node->right);
		}
		if(node->left){
			Stack.push(node->left);
		}
	}
}
void dfs_recursive(Node* root,vector<int>& ans)//深度优先递归实现
{
	if(root==NULL) return;
	Node* u=root;
	ans.push_back(u->v);
	if(u->left){
		dfs_recursive(u->left,ans);
	}
	if(u->right){
			dfs_recursive(u->right,ans);
		}
}

void bfs_recursive(Node* root,vector<int>& ans)//广度优先遍历递归实现
{
	if(root==NULL) return;
	Node* u=root;
	if(ans.size()==0){
		ans.push_back(u->v);
	}
	if(u->left){
		ans.push_back(u->left->v);
	}
	if(u->right){
		ans.push_back(u->right->v);
	}
	if(u->left){
			bfs_recursive(u->left,ans);
		}
	if(u->right){
		bfs_recursive(u->right,ans);
	}
}
void bfs(Node* root,vector<int>& ans)//广度优先非递归实现
{
	if(root==NULL) return;
	Node* u=root;
	queue<Node*> Queue;
	Queue.push(u);
	while (!Queue.empty()){
		Node *node=Queue.front();
		ans.push_back(node->v);
		Queue.pop();
		if(node->left){
			Queue.push(node->left);
		}
		if(node->right){
			Queue.push(node->right);
		}
	}
}



int main()
{
    Node* node1=new Node(4);
    Node* node2=new Node(5);
    Node* node3=new Node(6);
    Node* node4=new Node(2,node1,node2);
    Node* node5=new Node(3,node3);
    Node* node6=new Node(1,node4,node5);//建立一棵二叉数
    Node* root = node6;//根结点为node6
    vector<int>v;
    dfs_recursive(root,v);//从根结点开始深度遍历
    cout<<"dfs 递归遍历结果:";
    for(int i=0;i<v.size();i++){
    	cout<<v[i];
    }
    cout<<"\n"<<endl;
    vector<int> v1;
    bfs_recursive(root,v1);
    cout<<"bfs 递归遍历结果";
    for(int i=0;i<v1.size();i++){
    	cout<<v1[i];
    }
    cout<<"\n"<<endl;
    vector<int>v2;
    dfs(root,v2);//从根结点开始深度遍历
    cout<<"dfs 非递归遍历结果:";
    for(int i=0;i<v2.size();i++){
    	cout<<v2[i];
    }
    cout<<"\n"<<endl;
    vector<int> v3;
    bfs(root,v3);
    cout<<"bfs 非递归遍历结果";
    for(int i=0;i<v3.size();i++){
    	cout<<v3[i];
    }
    cout<<endl;
    return 0;
}