数据结构图的实训

2022.12.1四个题没空整，提前考试放假再说，当然深度和广度也要感谢同学提供帮助。

---

实现图的邻接矩阵和邻接表存储

//图的基本运算算法
#include "graph.h"
//------------------------------------------------------------
//----邻接矩阵的基本运算算法----------------------------------
//------------------------------------------------------------
//创建图的邻接矩阵
void CreateMat(MatGraph* &g, int A[MAXV][MAXV], int n, int e)
{
    //请在下面编写代码
    /***********Begin***********/
    int i, j;
    g->n = n;
    g->e = e;
    for(i = 0; i < g->n; i++)
        for(j = 0; j < g->n; j++)
            g->edges[i][j] = A[i][j];
    /***********Begin***********/
}
//输出邻接矩阵g
void DispMat(MatGraph* g)
{
    //请在下面编写代码: 输出时位宽为3，无穷大使用“-”输出。
    /***********Begin***********/
    int i, j;
    for(i = 0; i < g->n; i++)
    {
        for(j = 0; j < g->n; j++)
        {
            if(g->edges[i][j] != INF)
                printf("%3d", g->edges[i][j]);
            else
                printf("%3s", "-");
        }
        printf("\n");
    }
    /***********Begin***********/
}
//------------------------------------------------------------

//------------------------------------------------------------
//----邻接表的基本运算算法------------------------------------
//------------------------------------------------------------
//创建图的邻接表
void CreateAdj(AdjGraph *&G, int A[MAXV][MAXV], int n, int e)
{
    int i, j;
    ArcNode *p;
    G = (AdjGraph *)malloc(sizeof(AdjGraph));
    //请在下面编写代码
    /***********Begin***********/
    for(i = 0; i < n; i++) 
    {
        G->adjlist[i].firstarc = NULL;
    }
    for(i = 0; i < n; i++)
    {
        for(j = n - 1; j >= 0; j--)
        {
            if(A[i][j] != 0 && A[i][j] != INF)
            {
                p = (ArcNode *)malloc(sizeof(ArcNode));
                p->adjvex = j;
                p->weight = A[i][j];
                p->nextarc = G->adjlist[i].firstarc;
                G->adjlist[i].firstarc = p;
            }
        }
    }
    G->n = n;
    G->e = e;
    /***********Begin***********/
}
//输出邻接表G
void DispAdj(AdjGraph *G)
{
    int i;
    ArcNode *p;
    for (i = 0; i < G->n; i++) {
        /***********Begin***********/
        p = G->adjlist[i].firstarc;
        /***********Begin***********/
        printf("%3d: ", i);
        while (p != NULL) {
            printf("%3d[%d]->", p->adjvex, p->weight);
            /***********Begin***********/
            p = p->nextarc;
            /***********Begin***********/
        }
        printf("NULL\n");
    }
}
//销毁图的邻接表
void DestroyAdj(AdjGraph *&G)
{
    int i;
    ArcNode *pre, *p;
    for (i = 0; i < G->n; i++) {    //扫描所有的单链表
        pre = G->adjlist[i].firstarc; //p指向第i个单链表的首结点
        if (pre != NULL) {
            p = pre->nextarc;
            while (p != NULL) {     //释放第i个单链表的所有边结点
                free(pre);
                pre = p; p = p->nextarc;
            }
            free(pre);
        }
    }
    free(G);                        //释放头结点数组
}
//------------------------------------------------------------
 

邻接矩阵存储图的深度优先遍历

#include "graph.h"   //图的基本运算算法
bool visited[MAXV];             //访问标志数组

void DFS(MatGraph* G, int v)
{
    visited[v] = true;
    printf("%3d",v);
    for(int i=0;i<G->n;i++){
        if(G->edges[v][i] == 1 && !visited[i]){
            DFS(G,i);
        }
    }
}

邻接表存储图的广度优先遍历

//图的基本运算算法
#include "graph.h"

bool visited[MAXV];             //访问标志数组

const int MaxSize = 100;        //队列最大容量

//邻接表存储的图的广度优先遍历
void BFS(AdjGraph* G, int v)
{
    printf("  ");
    int w, i;
    ArcNode* p;
    int q[MaxSize];
    int head =0, tail = 0;
    for (i = 0; i < G->n; i++)
    {
        visited[i] = false;
    }
    printf("%d", v);
    visited[v] = true;
    q[++tail] = v;
    while (tail != head)
    {
        w = q[++head];
        p = G->adjlist[w].firstarc;
        while (p != NULL)
        {
            if (visited[p->adjvex] == false)
            {
                printf("%3d", p->adjvex);
                visited[p->adjvex] = true;
                q[++tail] = p->adjvex;
            }
            p = p->nextarc;
        }
    }
}

非连通图的连通分量

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int matrix[22][22];//关联矩阵 
int visited[22];
int N,E;
void DFS(int v);
void BFS(int v);
typedef struct Queue *Q;
struct Queue
{
	int rear;
	int front;
	int data[22];
};
void DFS(int v)
{
	printf("%d ",v);
	visited[v]=1;
    for(int i=0;i<N;i++)
    {
		if(!visited[i]&&matrix[v][i]==1)
		{
			DFS(i);	
		}	
	}
}
Q createQueue()
{
	Q q=(Q )malloc(sizeof(struct Queue));
	q->front=0;
	q->rear=0;
	return q;
}
void push(int data,Q q)   
{
	q->data[q->rear]=data;
	q->rear++;
}
int pop(Q q)
{
	q->front++;
	return q->data[q->front-1];
}
int isEmpty(Q q)
{
	if(q->rear==q->front)//空的 
		return 0;
	else
		return 1;
}
void BFS(int v)
{
	Q q=(Q )malloc(sizeof(struct Queue));
	int deleteV,i;
	q = createQueue();
	printf("%d ",v); 
	visited[v]=1;
	push(v,q);
	while(isEmpty(q))
	{
		deleteV = pop(q);
		for(i=0;i<N;i++)
		{
			if(!visited[i]&&matrix[deleteV][i]==1)
			{
				printf("%d ",i);
				visited[i]=1;
				push(i,q);
			}
		}
	}
}
int main() 
{
	int i,v2,v1;
	scanf("%d %d",&N,&E);
	for(i=0;i<E;i++)
	{
		scanf("%d %d",&v1,&v2);
		matrix[v1][v2]=1;//两个顶点相关联的
		matrix[v2][v1]=1; 
	}
	for(i=0;i<N;i++)
	{
		if(!visited[i])
		{
			printf("{ ");
		    DFS(i);
		    printf("}\n");
	    }
	}
	memset(visited,0,sizeof(visited));
	for(i=0;i<N;i++)
	{
		if(!visited[i])
		{
			printf("{ ");
			BFS(i);
			printf("}\n"); 
		}
	}
	return 0;
}