图---一维数组无向图（BFS+DFS）

#include 
#include 

#define true 1
#define false 0
#define INFINITY 1000000
#define MaxVertexNum 100
#define MaxArcNum 100


typedef char vname[5];//vertex name's length <= 5

struct GraphStruct {//创建一个最简单的无向图
    int vexnum, arcnum;
    int dist[MaxArcNum];
    int Visited[MaxVertexNum];
};
struct QueueStruct {
    int rear, front;
    int capacity;
    int Array[MaxVertexNum];
};
typedef struct GraphStruct* Graph;
typedef struct QueueStruct* Queue;

void printfError();
int computeNum( int a );
Graph createGraph();
void initializeGraph( Graph G );
void swap( int *p1, int *p2 );
void BFS( Graph G, int u );
void DFS( Graph G, int u );
void enQueue( Queue q, int u );
int deQueue( Queue q );
Queue createQueue();
void initializeQueue( Queue q );
int main( void ) {

    Graph G = createGraph();
    G->arcnum = 9;
    G->vexnum = 10;
    int i = 0;
    int V1, V2;
    int dist;
    int num = 0;
    FILE *fp = fopen("ArrayGraph.txt", "r");

    for( i = 0; i < G->arcnum; i++ ) {
        fscanf(fp, "%d %d %d", &V1, &V2, &dist);
        if( V1 < V2 ) {
            swap( &V1, &V2 );
        }
        num = computeNum( V1-1 ) + V2-1;

        G->dist[num] = dist;
    }

    BFS( G, 0 );
    DFS( G, 0 );
    return 0;
}
void printfError() {
    printf("Space Error!");
    exit( 0 );
}
void swap( int *p1, int *p2 ) {
    int tmp = 0;
    tmp = *p2;
    *p2 = *p1;
    *p1 = tmp;
}
void BFS( Graph G, int u ) {
    Queue q = createQueue();
    G->Visited[u] = true;
    printf("%d ", u+1);
    enQueue( q, u );
    int k = 0;
    int i = 0;
    int num = 0;

    while( q->front != q->rear ) {
        k = deQueue( q );

        for( i = 0; i < k; i++ ) {
            num = computeNum( i );

            if( !G->Visited[i] && G->dist[num+i] != INFINITY ) {
                printf("%d ", i+1);
                G->Visited[i] = true;
                enQueue( q, i );
            }
        }

        for( i = k+1; i < G->vexnum; i++ ) {
            num = computeNum( i ) + k;

            if( !G->Visited[i] && G->dist[num] != INFINITY ) {
                printf("%d ", i+1);
                G->Visited[i] = true;
                enQueue( q, i );
            }
        }
    }
}
void DFS( Graph G,int u ) {

    if( G->Visited[u] ) {
        printf("%d\n", G->Visited[u]);
        return;
    }
    G->Visited[u] = true;
    printf("%d ", u+1);
    int i = 0;
    int num = computeNum( u );
    for( i = 0; i < u; i++ ) {
        if( !G->Visited[i] && G->dist[num+i] != INFINITY ) {
            DFS( G, i );
        }
    }
    for( i = u+1; i < G->vexnum; i++ ) {
        num = computeNum( i ) + u;
        if( !G->Visited[i] && G->dist[num] != INFINITY ) {
            DFS( G, i );
        }
    }

}
int computeNum( int a ) {
    return a*(a-1)/2;
}
Graph createGraph() {
    Graph G = ( Graph )malloc( sizeof( struct GraphStruct ) );
    if( !G ) {
        printfError();
    }
    initializeGraph( G );

    return G;
}
void initializeGraph( Graph G ) {
    int i = 0;
    scanf("%d %d", &G->vexnum, &G->arcnum);
    for( i = 0; i < computeNum( G->vexnum ); i++ ) {
        G->dist[i] = INFINITY;
    }
    for( i = 0; i < G->vexnum; i++ ) {
        G->Visited[i] = false;//好像这里也可以提出来一个函数
    }

}
void enQueue( Queue q, int u ) {
    if( (q->rear+1) % MaxVertexNum == q->front ) {
        printf("IsFull");
        return;
    }
    q->rear = ( q->rear+1 ) % MaxVertexNum;
    q->Array[q->rear] = u;
}
int deQueue( Queue q ) {
    if( q->front == q->rear ) {
        printf("IsEmpyu");
        return 1314521;
    }

    q->front = ( q->front+1 ) % MaxVertexNum;

    return q->Array[q->front];
}
Queue createQueue() {
    Queue q = ( Queue )malloc( sizeof(struct QueueStruct) );
    if( !q ) {
        printfError();
    }

    initializeQueue( q );

    return q;
}
void initializeQueue( Queue q ) {
    q->capacity = MaxVertexNum-1;
    q->front = q->rear = 0;
}

好吧，无向图，最后把他优化一下，使main函数看得简单一点。然后用了一个从文本中输入数据的语法，算还行。