深度和广度优先搜索C实现-栈和队列辅助

/*使用邻接矩阵，只关注与搜索算法本身，所以没有考虑边所带的信息之类的东西. 借助堆栈和队列的方法实现深度优先和广度优先搜索 
* 广度优先也可以使用递归实现
*/ 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <queue>
#include <stack>

#define N 6
#define N_R 200
//#define InfoType char

using namespace std;

static int a[N][N]={
            {0,1,0,0,1},
            {1,0,1,1,1},
            {0,1,0,1,0},
            {0,1,1,0,1},
            {1,1,0,1,0}
};  


/*
//结点信息 
typedef struct Info{
    char * info;
}Info, *PInfo;
*/

typedef struct node{
    int key;           //结点索引关键字 
   // InfoType inf;       //结点信息指针 
    int visit;         //访问标志位，-1代表黑色：完全访问过，0代表灰色，有相邻节点未被访问，1代表未访问。 
    struct node *p;    //该结点的父结点（即连接结点）
    int d;             //与父结点之间的距离 
}Gnode, *PGnode;            

typedef struct{
    PGnode node[N];           //所有顶点 
    int vexnum;                 //顶点数量 
    int arcnum;                 //边的数量
}Graph, *PGraph;

//用来维护广度优先搜索的队列    
queue<PGnode> qBFS;
//用来维护深度优先搜索的栈  
stack<PGnode> sDFS;

PGnode IniGnode(int key){
    PGnode gNode=(PGnode)malloc(sizeof(Gnode));
    gNode->key=key;
    gNode->visit=1; //初始化未访问 
    gNode->p=NULL;
    gNode->d=0;
    return gNode;
} 
     
void IniGraph(PGraph *g, int a[N][N]){
    //将结点初始化 
    *g=(PGraph)malloc(sizeof(Graph));
    for(int i=0;i<N;i++){
        (*g)->node[i]=IniGnode(i);
    }
}

void BFS(PGraph g, PGnode s){
    int index,i;
    PGnode u,v;   //u为当前处理结点，v为相邻结点 
    s->visit=0;
    qBFS.push(s);
    while(!qBFS.empty()){
        u=qBFS.front();  //获取队列第一个元素 
        printf("(key=%d,distance=%d)->",u->key,u->d);  
        qBFS.pop();      //弹出元素
        index=u->key;
        for(int i=0;i<N;i++){
            if(a[index][i] == 1){  //找到相邻结点
                v=g->node[i];
                if(v->visit == 1){ //节点未被访问                      
                     v->visit=0;   //找到节点 
                     v->d=u->d + 1;
                     v->p=u;
                     qBFS.push(v);
                }
            }
        }
        u->visit=-1;  //已经将所有邻接节点处理完 
    }
}

void DFS(PGraph g, PGnode s){
    int index,i,flag;
    PGnode u,v;   //u为当前处理结点，v为相邻结点 
    s->visit=0;
    sDFS.push(s);
    printf("(key=%d,distance=%d)->",s->key,s->d);
    while(!sDFS.empty()){
        u=sDFS.top();      
        //sBFS.pop();
        index=u->key;
        for(i=0;i<N;i++){
            if(a[index][i] == 1){  //找到相邻结点
                v=g->node[i];
                if(v->visit == 1){ //节点未被访问                      
                     v->visit=0;   //找到节点 
                     v->d=u->d + 1;
                     v->p=u;
                     printf("(key=%d,distance=%d)->",v->key,v->d);
                     sDFS.push(v);
                     break;
                }
            }
            
        }
        if(i==N){  
            sDFS.pop();   //如果该结点的所有子节点都查询完，则弹出。
            u->visit=-1;
        }    
    }       
} 
            
int main(){
    PGraph g;
    IniGraph(&g,a);
   // printf("宽度遍历结果为:\n");
   // BFS(g, g->node[0]);
    printf("深度遍历结果为:\n");
    DFS(g, g->node[0]);
    system("pause");
    return 0;
} 

相关链接：

http://www.cppblog.com/woaidongmao/archive/2009/01/04/71164.html