图的创建与遍历

图是非线性结构，有两种存储结构，一种是邻接矩阵，另一种是邻接表。

邻接矩阵用一个二维数组来表示。

代码如下：

#include<stdio.h> 
#include<stdlib.h>
#define max_len 100

typedef struct node{
    int num;                    //下标 
    int data;                    //数据 
}Point;                            //节点类型 

typedef struct{
    int pointNum;                //顶点数 
    int edgeNum;                //边数 
    Point pointArray[max_len];                //用数组来存放顶点 
    int edgeArray[max_len][max_len];        //用数组来存放边 
}AdjMatrix;                        //矩阵类型 

AdjMatrix *create_AdjMatrix(){
    
    AdjMatrix *adjMatrix = (AdjMatrix *)malloc(sizeof(AdjMatrix));
    
    int i,j,n;
    printf("输入顶点数:");
    scanf("%d",&i);
    printf("输入边数:");
    scanf("%d",&j);
    
    adjMatrix->pointNum = i;
    adjMatrix->edgeNum = j;
    
    for(i=0;i<adjMatrix->pointNum;i++){
        adjMatrix->pointArray[i].data = i;
        adjMatrix->pointArray[i].num = i;
    }
    
    for(i=0;i<adjMatrix->pointNum;i++)
        for(j=0;j<adjMatrix->pointNum;j++)
            adjMatrix->edgeArray[i][j] = 0;
    
    printf("输入边的信息:");
    for(i=0;i<adjMatrix->edgeNum;i++){
        scanf("%d %d",&j,&n);
        adjMatrix->edgeArray[j][n] = 1;
    }
    
    return adjMatrix;
}

void display(AdjMatrix *adjMatrix){
    
    printf("
");
    
    int i,j;
    for(i=0;i<adjMatrix->pointNum;i++){
        for(j=0;j<adjMatrix->pointNum;j++)
            printf("%d ",adjMatrix->edgeArray[i][j]);
        printf("
");
    }
    
}

void main(){
    
    AdjMatrix *adjMatrix = create_AdjMatrix();
    display(adjMatrix);
    
}

邻接表用链表数组来表示，即链表数组中的每一个元素都是一个链表的头结点，然后这个头结点后面就会跟着一串的链节点，用来表示头结点代表的图中元素可以直接到达链节点代表的图中元素。

代码如下：

#include<stdio.h> 
#include<stdlib.h>
#define max_len 100

typedef struct node{
    int adjvex;
    int data;
    struct node *nextarc;
}ARCnode;                            //节点类型 

typedef struct{
    int vexdata;
    ARCnode *firstarc;
}VEXnode;                            //头结点类型 

typedef struct{
    int pointNum;                    //顶点数 
    int edgeNum;                    //边数 
    VEXnode vexnode[max_len];        //头结点数组 
}ALGraph;                            //邻接表类型 


ALGraph *create_ALGraph(){
    
    ALGraph *algraph = (ALGraph *)malloc(sizeof(ALGraph));
    ARCnode *arcnode;
    
    int i,j,n;
    printf("输入顶点数:");
    scanf("%d",&i);
    printf("输入边数:");
    scanf("%d",&j);
    
    algraph->pointNum = i;
    algraph->edgeNum = j;

    
    for(i=0;i<algraph->edgeNum;i++){
        algraph->vexnode[i].vexdata = i;
        algraph->vexnode[i].firstarc = NULL;
    }
    
    printf("输入边的信息:");
    for(i=0;i<algraph->edgeNum;i++){
        scanf("%d %d",&j,&n);
        arcnode = (ARCnode *)malloc(sizeof(ARCnode));
        arcnode->adjvex = n;
        arcnode->data = n;
        arcnode->nextarc = algraph->vexnode[j].firstarc;
        algraph->vexnode[j].firstarc = arcnode;
    }
    
    return algraph;
}

void display(ALGraph *algraph){
    
    ARCnode *arcnode;
    
    int i;
    for(i=0;i<algraph->edgeNum;i++){
        printf("%d ",algraph->vexnode[i].vexdata);
        arcnode = algraph->vexnode[i].firstarc;
        while(arcnode!=NULL){
            printf("%d ",arcnode->adjvex);
            arcnode = arcnode->nextarc;
        }
        printf("
");
    }
    
}

void main(){
    
    ALGraph *algraph = create_ALGraph();
    display(algraph);
    
}

深度优先遍历

算法：首先访问某个顶点V1，然后访问与v1邻接的顶点V2，再访问与v2邻接的顶点V3，然后不断重复，直到邻接的顶点vi被访问过，然后退回到Vi-1，访问Vi-1没被访问过的邻接点，再不断重复这两个过程即可访问完所有节点

代码如下：

#include<stdio.h>
#include<stdlib.h>
#define max_len 100
int visited[max_len];

typedef struct node{
    int adjvex;
    struct node *nextarc;
    int info;
}ARCnode; 


typedef struct vexnode{
    int vexdata;
    ARCnode *firstarc;
}VEXnode;

typedef struct{
    VEXnode vexnode[max_len];
    int vexnum,arcnum;
}ALGraph;


ALGraph *create_ALGraph(){
    
    int i,j,n;
    ALGraph *a = (ALGraph *)malloc(sizeof(ALGraph));
    ARCnode *p;

    printf("输入顶点数:
");
    scanf("%d",&j);
    printf("输入边数:
");
    scanf("%d",&n);
    
    a->vexnum = j;
    a->arcnum = n;
    
    for(i=0;i<a->vexnum;i++){
        a->vexnode[i].vexdata = i;
        a->vexnode[i].firstarc = NULL;
    }
    
    printf("
");
    printf("输入边的信息:
");
    for(i=0;i<a->arcnum;i++){
        scanf("%d %d",&j,&n);
        p = (ARCnode *)malloc(sizeof(ARCnode));
        p->adjvex = n;
        p->info = n;
        p->nextarc = a->vexnode[j].firstarc;
        a->vexnode[j].firstarc = p;
    }
    
    return a;
}

//深度优先遍历使用递归来遍历所有节点 
void dfs(ALGraph a,int v){
    
    visited[v] = 1;                //访问过的顶点标识为1 
    printf("%d ",v);
    VEXnode vex = a.vexnode[v];
    ARCnode *arc = vex.firstarc;
    while(arc!=NULL){
        if(visited[arc->adjvex]==0)//判断是否访问过 
            dfs(a,arc->adjvex);    //访问该顶点的邻接点 
        arc = arc->nextarc;        //如果访问过，则退回到该节点，寻找没有被访问过的节点 
    }
    
}

//深度优先遍历函数 
void dfs_trave(ALGraph a){
    
    int i;
    for(i=0;i<a.vexnum;i++)
        visited[i] = 0;            //标识数组，用来记录被访问过的顶点 
                                //0代表没有访问过，1则反之 
    for(i=0;i<a.vexnum;i++)
        if(visited[i] == 0)
            dfs(a,i);
    
}

void display(ALGraph *a){
    
    printf("
");
    
    int i,j;
    for(i=0;i<a->vexnum;i++){
        j = a->vexnode[i].vexdata;
        printf("%d ",j);
        ARCnode *arc = a->vexnode[i].firstarc; 
        while(arc!=NULL){
            printf("%d ",arc->adjvex);
            arc = arc->nextarc;
        }
        printf("
");
    }
    
}

void main(){
    
    ALGraph *a = create_ALGraph();
    display(a);
//    ALGraph alg = *a;
//    dfs_trave(alg);
    
}

广度优先遍历

算法：访问某个顶点V1，然后把V1的所有邻接点全部访问，比如有V2、V3、V4。这就是一层，然后再访问V2的所有邻接点，接着访问V3、V4的所有邻接点。当然访问过的顶点不再需要访问了。

代码如下：广度遍历需要一个队列来暂时存储访问过得顶点。然后根据这个顶点来访问他的所有邻接点。

#include<stdio.h>
#include<stdlib.h>
#define max_len 100
int visited[max_len];

typedef struct{
    int data[max_len];
    int front,rear;
}SeqQueue; 

typedef struct node{
    int adjvex;
    struct node *nextarc;
    int info;
}ARCnode; 

typedef struct vexnode{
    int vexdata;
    ARCnode *firstarc;
}VEXnode;

typedef struct{
    VEXnode vexnode[max_len];
    int vexnum,arcnum;
}AlGraph;

SeqQueue *init_SeqQueue(){
    
    SeqQueue *sq = (SeqQueue *)malloc(sizeof(SeqQueue));
    sq->front = 0;
    sq->rear = 0;
    
    return sq;
}

int isEmpty(SeqQueue *sq){
    
    if(sq->front==sq->rear)
        return 1;
    return 0;
    
}

int delQueue(SeqQueue *sq){
    
    if(sq->rear==sq->front)
        return ;
    sq->rear = (sq->rear+1)%max_len;
    return sq->data[sq->rear];
    
}

void inQueue(SeqQueue *sq,int n){
    
    
    sq->front = (sq->front+1)%max_len;
    if(sq->rear==sq->front)
        return ;
    sq->data[sq->front] = n;
    
}

AlGraph *create_AlGraph(){
    
    int i,j,n;
    AlGraph *a = (AlGraph *)malloc(sizeof(AlGraph));
    ARCnode *p;

    printf("输入顶点数:
");
    scanf("%d",&j);
    printf("输入边数:
");
    scanf("%d",&n);
    
    a->vexnum = j;
    a->arcnum = n;
    
    for(i=0;i<a->vexnum;i++){
        a->vexnode[i].vexdata = i;
        a->vexnode[i].firstarc = NULL;
    }
    
    printf("
");
    printf("输入边的信息:
");
    for(i=0;i<a->arcnum;i++){
        scanf("%d %d",&j,&n);
        p = (ARCnode *)malloc(sizeof(ARCnode));
        p->adjvex = n;
        p->info = n;
        p->nextarc = a->vexnode[j].firstarc;
        a->vexnode[j].firstarc = p;
    }
    
    return a;
}

 
void bfs(AlGraph a,int v,SeqQueue *sq){
    
    printf("
%d ",v);
    visited[v] = 1;
    inQueue(sq,v);            //被访问过的顶点入队列 
    
    int i;
    while(!isEmpty(sq)){    //如果队列非空则继续访问 
        i = delQueue(sq);    //寻找出队顶点的所有邻接点 
        ARCnode *arc = a.vexnode[i].firstarc;
        while(arc!=NULL){
            if(visited[arc->adjvex]!=1){    
                printf("%d ",arc->adjvex);
                visited[arc->adjvex] = 1;    //标识为已被访问过 
                inQueue(sq,arc->adjvex);    //被访问过的顶点入队列 
            }
            arc = arc->nextarc;    
        }
    }
    
}

//广度优先遍历函数
void bfs_trave(AlGraph a,SeqQueue *sq){
    
    int i;
    for(i=0;i<a.vexnum;i++)
        visited[i] = 0;
    
    for(i=0;i<a.vexnum;i++){
        if(visited[i] == 0)
            bfs(a,i,sq);
    }
    
}

void display(AlGraph *a){
    
    printf("
");
    
    int i,j;
    for(i=0;i<a->vexnum;i++){
        j = a->vexnode[i].vexdata;
        printf("%d ",j);
        ARCnode *arc = a->vexnode[i].firstarc; 
        while(arc!=NULL){
            printf("%d ",arc->adjvex);
            arc = arc->nextarc;
        }
        printf("
");
    }
    
}


void main(){
    
    SeqQueue *sq = init_SeqQueue();
    AlGraph *a = create_AlGraph();
    display(a);
    AlGraph alg = *a;
    bfs_trave(alg,sq);
    
}