图的深度优先搜索和广度优先搜索

#include <iostream>
#include <queue>
#include <stack>
using namespace std;

//0：表示不连通
//1：表示连通
//无自环路
const int graph_arr[11][11] = {
{0,1,0,0,0,0,1,0,0,1,1},//V0
{1,0,1,0,0,1,1,0,0,0,1},//V1
{0,1,0,1,1,0,0,0,1,0,0},//V2
{0,0,1,0,1,0,0,0,0,0,0},//V3
{0,0,1,1,0,1,0,0,0,0,0},//V4
{0,1,0,0,1,0,0,0,0,0,0},//V5
{1,1,0,0,0,0,0,1,0,0,0},//V6
{0,0,0,0,0,0,1,0,1,1,0},//V7
{0,0,1,0,0,0,0,1,0,0,0},//V8
{1,0,0,0,0,0,0,1,0,0,1},//V9
{1,1,0,0,0,0,0,0,0,1,0} //V10
};

bool visited[11] = {false,false,false,false,false,false,false,false,false,false,false};
//bool visited[11] = {false};

struct Node{
int no;     //顶点标号
struct Node* next;  //与该顶点相连的顶点
Node():no(-1),next(NULL){

}
};

struct EdgeNode{
struct Node* first_node;//每个便表集合的头节点，也就是 V0,V1,V2...V10
struct EdgeNode* next;  //指向下一个头节点
int nodes_num;
EdgeNode():nodes_num(-1),first_node(NULL),next(NULL){

}
};

/**
*   初始化图的邻接链表
*/
EdgeNode* init_graph(){
EdgeNode* graph = (EdgeNode*)malloc(sizeof(struct EdgeNode));
EdgeNode* _graph = graph;

for(int i=0;i<11;i++){
Node* node = (Node*)malloc(sizeof(struct Node));
node->no = i;
graph->first_node = node;
EdgeNode* tmp0 = (EdgeNode*)malloc(sizeof(struct EdgeNode));
graph->next = tmp0;
graph->nodes_num = 0;

for(int j=0;j<11;j++){
if(graph_arr[i][j] == 1){
Node* tmp = (Node*)malloc(sizeof(struct Node));
tmp->no = j;
node->next = tmp;
node = tmp;
graph->nodes_num ++;
}
}
graph = tmp0;
}
return _graph;
}

/**
*   邻接链表 BFS
*   非递归方式实现
*/
void BFS(EdgeNode* graph){
queue<EdgeNode*> que;
EdgeNode* tmp = graph;
que.push(tmp);
while(!que.empty()){
tmp = que.front();
que.pop();
Node* node = tmp->first_node;
for(int j=0;j<= tmp->nodes_num;j++){
if(!visited[node->no]){
cout<<"编号："<<node->no<<endl;
visited[node->no] = true;
EdgeNode* tmp0 = tmp->next;
while(tmp0->next){
if(tmp0->first_node->no == node->no){
que.push(tmp0);
break;
}
tmp0 = tmp0->next;
}
}
node = node->next;
}
}
}
/**
*   邻接链表 DFS
*   递归方式实现
*/
void DFS(EdgeNode* graph){
EdgeNode* tmp = graph;
Node* node = tmp->first_node;
for(int j=0;j<= tmp->nodes_num;j++){
if(!visited[node->no]){
cout<<"编号："<<node->no<<endl;
visited[node->no] = true;
EdgeNode* tmp0 = tmp->next;
while(tmp0->next){
if(tmp0->first_node->no == node->no){
DFS(tmp0);
break;
}
tmp0 = tmp0->next;
}
}
node = node->next;
}
}

//寻找临接表中某个便表集合中没有被访问的结点
EdgeNode* find_no_visited(EdgeNode* first_node){

EdgeNode* edge_node = first_node;
Node* node = first_node->first_node;

while(node->no != -1){
cout<<node->no<<endl;
if(!visited[node->no]){
while(edge_node){
if(edge_node->first_node->no == node->no){
return edge_node;
}
edge_node = edge_node->next;
}
}
node = node->next;
}
cout<<endl;
return NULL;
}

/**
*   邻接链表 DFS
*   非递归方式实现
*/
void DFS0(EdgeNode* graph){
EdgeNode* tmp = graph;
stack<EdgeNode*> stk;
Node* node = tmp->first_node;
stk.push(tmp);
cout<<"编号："<<node->no<<endl;
visited[node->no] = true;
while(!stk.empty()){
tmp = stk.top();
EdgeNode* no_visited =  find_no_visited(tmp);
if(no_visited->next!= NULL) {
cout<<"编号：";
cout<<no_visited->first_node->no<<endl;
visited[no_visited->first_node->no] = true;
stk.push(no_visited);
}else{
stk.pop();
}
}

}

int main(int argc, char** argv) {
//  EdgeNode* graph = init_graph();
//  visited[0] = true;
//  visited[1] = true;
//  visited[2] = true;
//  visited[3] = true;
//  visited[4] = true;
//  visited[5] = true;
//  visited[6] = true;
//  cout<<find_no_visited(graph)->first_node->no;
DFS(init_graph());
system("pause");
return 0;
}