dfs

#include <malloc.h>  
#include <iostream>  
using namespace std;  
  
#define INFINITY 32767  
#define MAX_VEX 50 //最大顶点个数  
 
#define OK 1  
#define FALSE 0  
#define TRUE 1  
#define ERROR -1  
   
bool *visited;  //动态分配访问标志数组  
   
//图的邻接矩阵存储结构  
typedef struct {  
    char *vexs;  //动态分配空间存储顶点向量  
    int arcs[MAX_VEX][MAX_VEX];  //邻接矩阵  
    int vexnum, arcnum;  //图的当前定点数和弧数   
}Graph;  
  
  
//图G中查找顶点c的位置  
int LocateVex(Graph G, char c) {  
    for(int i = 0; i < G.vexnum; ++i) {  
        if(G.vexs[i] ==  c) return i;  
    }  
    return ERROR;  
}  
    
//创建无向网  
void CreateUDN(Graph &G){  
    //采用数组（邻接矩阵）表示法，构造无向网G  
    cout << "请输入定点数和弧数：";  
    cin >> G.vexnum >> G.arcnum;  
    cout << "请输入" << G.vexnum << "个顶点" << endl;  
    G.vexs = (char *) malloc((G.vexnum+1) * sizeof(char));  //需要开辟多一个空间存储'\0'  
    //构造顶点向量  
    for(int i = 0; i < G.vexnum; i++) {  
        cout << "请输入第" << i+1 << "个顶点：";  
        cin >> G.vexs[i];  
    }  
    G.vexs[G.vexnum] = '\0';  
      
    //初始化邻接矩阵  
    for(i = 0; i < G.vexnum; ++i)   
        for( int j = 0; j < G.vexnum; j++)   
            G.arcs[i][j] = INFINITY;     
      
    cout << "请输入" << G.arcnum << "条弧" << endl;  
    char a, b;  
    int s1, s2;  
    for(i = 0; i < G.arcnum; ++i) {  
        cout << "请输入第" << i+1 << "条弧：";  
        cin >> a >> b ;  //输入依附于弧的权值  
        s1 = LocateVex(G,a);  //找到a和b在顶点向量中的位置  
        s2 = LocateVex(G,b);    
        G.arcs[s1][s2] = G.arcs[s2][s1] = 1;  //权值默认为1  
    }  
}  
  
//图G中顶点k的第一个邻接顶点  
int FirstVex(Graph G,int k){  
    for(int i = 0; i < G.vexnum; ++i)   
        if (G.arcs[k][i] != INFINITY) return i;  
    return ERROR;  
}  
  
//返回i（相对于j）的下一个邻接顶点  
int NextVex(Graph G,int i,int j){  
    for(int k = j+1; k < G.vexnum; ++k)   
        if(G.arcs[i][k] != INFINITY) return k;  
    return ERROR;  
}  
  
void DFS(Graph G, int v) {  
    //从第v个顶点出发递归地深度优先遍历图G  
    visited[v] = TRUE;  
    cout << G.vexs[v] << "  ";  
    for(int w = FirstVex(G,v); w >= 0; w = NextVex(G,v,w))  
        if(!visited[w]) DFS(G,w);  
}  
  
//深度优先遍历  
void DFSTraverse(Graph G, int i) {  
    for(int j = 0; j < G.vexnum; ++j) {  //初始化所有的顶点状态为未被访问  
        visited[j] = FALSE;  
    }  
    //遍历结点  
    for(; i < G.vexnum; ++i)   
        if(!visited[i]) DFS(G,i);  
}  
  
//主函数  
void main(){  
    Graph G;  
    CreateUDN(G);  
    visited = (bool *) malloc(G.vexnum * sizeof(bool));  
    cout << endl << "深度优先遍历：";  
    DFSTraverse(G,0);  
    cout << endl;  
}