图的深度优先搜索

这个写法我认为精简

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

typedef struct node
{
    int vertex;
    struct node *nextnode;
}*graph,Linknode;

struct node head[9];
int visited[9];

void creategraph( int *node,int num )
{
    graph newnode;
    graph ptr;
    int from;
    int to;
    int i;
    
    for( i=0; i<num; i++ )
    {
        from = node[i*2];
        to = node[i*2+1];
        
        newnode = ( graph ) malloc( sizeof( Linknode ) );
        newnode -> vertex = to;
        newnode -> nextnode = NULL;
        
        ptr = &(head[from]);
        while( ptr->nextnode!=NULL )
            ptr = ptr -> nextnode;
        ptr->nextnode = newnode;
    }
}
        
void DFS ( int current )
{
    graph ptr;
    visited[current] = 1;
    printf("顶点[%d] ",current);
     ptr = head[current].nextnode;
    while( ptr!=NULL )
    {
        if( visited[ptr->vertex]!=1 )
            DFS(ptr->vertex);
        ptr = ptr -> nextnode;
    }    
}    
    
int main( )
{
    graph ptr;    
    int i;
    
    int node[20][2]={                                                        
       {1,2},{2,1},
       {1,3},{3,1},
       {2,4},{4,2},
       {2,5},{5,2},
       {3,6},{6,3},
       {3,7},{7,3},
       {4,8},{8,4},
       {5,8},{8,5},
       {6,8},{8,6},
       {7,8},{8,7}  
    };

    for( i=1; i<=8; i++ )
    {
        head[i].vertex = i;
        head[i].nextnode = NULL;
        visited[i] = 0;
    }
    
    creategraph(*node,20);
    
    printf("图的邻接表内容：\n");
    for( i=1; i<=8; i++ )
    {
        ptr = head[i].nextnode;
        printf("[%d]:",i);
        while( ptr != NULL )
        {
            printf("%d ",ptr->vertex);
            ptr=ptr->nextnode;
        }
        printf("\n");
    }
    printf("\n深度优先搜索遍历的结果为：\n");     
    DFS( 1 );
    printf("\n\n");
    system("pause");
    return 0;    
}

 这个写法比较粗糙

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>

typedef int  VertexType;
#define MAX_VERTEX_NUM 20

typedef struct ArcNode{
    int                data;
    struct ArcNode *nextarc;
}ArcNode;

typedef struct VNode{
    VertexType data;
    ArcNode *fistarc;
}VNode,AdjList[MAX_VERTEX_NUM];

typedef struct{
    AdjList vertices;
    int vexnum,arcnum;
}ALGraph;

typedef enum{FALSE,TRUE} Boolean;
Boolean visited[MAX_VERTEX_NUM];

void CreatALGraph( ALGraph *G )
{
    int i;
    int j;
    int k;
    ArcNode *S;
    printf("请输入顶点数和边数:\n");
    scanf("%d %d",&G->vexnum,&G->arcnum);
    printf("请输入定点编号：\n"); 
    for( i=1; i<=G->vexnum; i++ )
    {
        scanf("%d",&G->vertices[i].data);
        G->vertices[i].fistarc = NULL;
    }
    printf("请输入由两个顶点构成的边，如（0，1）\n");
    for( k=0; k<G->arcnum; k++ )
    {
        scanf("%d %d",&i,&j);       
        S = (ArcNode *)malloc(sizeof(ArcNode));
        S->data = j;
        S->nextarc = G->vertices[i].fistarc;
        G->vertices[i].fistarc = S;
        S = (ArcNode *)malloc(sizeof(ArcNode));
        S->data = i;
        S->nextarc = G->vertices[j].fistarc;
        G->vertices[j].fistarc = S;
    }          
}  

void DFSM( ALGraph *G, int i )
{
    ArcNode *p;
    printf("%d\n",G->vertices[i].data);
    visited[i] = TRUE;
    p = G->vertices[i].fistarc;
    while( p ) {
        if( !visited[p->data] )
            DFSM(G,p->data);
    p = p->nextarc;
  }
}

void DFS( ALGraph *G )
{
    for( int i=1; i<=G->vexnum; i++ )
        visited[i] = FALSE;
    for( int i=1; i<=G->vexnum; i++ )
    {
        if( !visited[i])
            DFSM(G,i);
    }
}    
        
int main( )
{
    ALGraph *G;
    G = (ALGraph *)malloc(sizeof(ALGraph));
    CreatALGraph(G);
    printf("遍历的结果与构造的顺序有关!\n");
    DFS(G);
    system("pause");
    return 0;
}