期末复习题_数图

已于 2024-06-23 02:19:50 修改
阅读量159 收藏
点赞数 2
文章标签： 算法 图论 数据结构
于 2024-06-23 02:19:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79699578/article/details/139891270
版权
13. 2023-期末复习-图的遍历-广度优先搜索遍历连通图-邻接矩阵法
/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */


#include "stdio.h"    

#include "stdlib.h"   


#include "math.h"  

#include "time.h"


#define OK 1

#define ERROR 0

#define TRUE 1

#define FALSE 0


typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */

typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */


typedef char VertexType; /* 顶点类型 */

typedef int EdgeType; /* 边上的权值类型 */


#define MAXSIZE 9 /* 存储空间初始分配量 */

#define MAXEDGE 15

#define MAXVEX 9


typedef struct

{

	VertexType vexs[MAXVEX]; /* 顶点表 */
	
	EdgeType arc[MAXVEX][MAXVEX];/* 邻接矩阵，可看作边表 */
	
	int numVertexes, numEdges; /* 图中当前的顶点数和边数 */

}MGraph;


/* 用到的队列结构与函数********************************** */


/* 循环队列的顺序存储结构 */

typedef struct

{

	int data[MAXSIZE];
	
	int front;    	/* 头指针 */
	
	int rear;/* 尾指针，若队列不空，指向队列尾元素的下一个位置 */

}Queue;


/* 初始化一个空队列Q */

Status InitQueue(Queue* Q)

{

	Q->front = 0;

	Q->rear = 0;

	return  OK;

}


/* 若队列Q为空队列,则返回TRUE,否则返回FALSE */

Status QueueEmpty(Queue Q)

{

	if (Q.front == Q.rear) /* 队列空的标志 */
	
		return TRUE;
	
	else
	
		return FALSE;

}


/* 若队列未满，则插入元素e为Q新的队尾元素 */

Status EnQueue(Queue* Q, char e)

{

	if ((Q->rear + 1) % MAXSIZE == Q->front)/* 队列满的判断 */

		return ERROR;

	Q->data[Q->rear] = e;/* 将元素e赋值给队尾 */

	Q->rear = (Q->rear + 1) % MAXSIZE;/* rear指针向后移一位置， */

/* 若到最后则转到数组头部 */

	return  OK;

}


/* 若队列不空，则删除Q中队头元素，用e返回其值 */

Status DeQueue(Queue* Q, char* e)

{

	if (Q->front == Q->rear)/* 队列空的判断 */
	
		return ERROR;
	
	*e = Q->data[Q->front];/* 将队头元素赋值给e */
	
	Q->front = (Q->front + 1) % MAXSIZE;/* front指针向后移一位置， */
	
	/* 若到最后则转到数组头部 */
	
	return  OK;

}

/* ****************************************************** */



void CreateMGraph(MGraph* G)

{

	int i, j;


	G->numEdges = 15;

	G->numVertexes = 9;


/* 读入顶点信息，建立顶点表 */

	G->vexs[0] = 'A';

	G->vexs[1] = 'B';

	G->vexs[2] = 'C';

	G->vexs[3] = 'D';

	G->vexs[4] = 'E';

	G->vexs[5] = 'F';

	G->vexs[6] = 'G';

	G->vexs[7] = 'H';

	G->vexs[8] = 'I';



	for (i = 0; i < G->numVertexes; i++)/* 初始化图 */
	
	{
	
		for (j = 0; j < G->numVertexes; j++)
		
		{
		
			G->arc[i][j] = 0;
		
		}
	
	}


	G->arc[0][1] = 1;

	G->arc[0][5] = 1;


	G->arc[1][2] = 1;

	G->arc[1][8] = 1;

	G->arc[1][6] = 1;


	G->arc[2][3] = 1;

	G->arc[2][8] = 1;


	G->arc[3][4] = 1;

	G->arc[3][7] = 1;

	G->arc[3][6] = 1;

	G->arc[3][8] = 1;

	G->arc[4][5] = 1;

	G->arc[4][7] = 1;

	G->arc[5][6] = 1;

	G->arc[6][7] = 1;

	for (i = 0; i < G->numVertexes; i++)	
	{	
		for (j = i; j < G->numVertexes; j++)		
		{		
			G->arc[j][i] = G->arc[i][j];		
		}	
	}
}

/*
1.这里没说从哪个顶点开始进行广度搜索，就从第一个节点进行
2，要建立一个visit数组记录每个节点的访问情况
3.如果该结点没有进行过访问，就开始对这个节点进行访问，并将该节点的visit储存的状态置为真。
4.然后要依次遍历与该节点相连的节点，先将自己进行入队，接下来进行循环
5.出队，遍历至第一个到与之相连的且没有访问过的节点，对它进行访问，然后将其visit状态置为真，将其入队。
*/


/* PRESET CODE END - NEVER TOUCH CODE ABOVE */

void BFSTraverse(MGraph G)
{
   /*请补充代码*/
   int i, j;
   Queue Q;
   InitQueue(&Q);
   int visit[MAXVEX] ;
   for(i = 0 ;i < MAXVEX; i ++)
   {
   		visit[i] = FALSE; 
	}
	
	for(i = 0; i < G.numVertexes ;i ++)
	{
		if(!visit[i]) 
		{
			printf("%c ",G.vexs[i]);	
			visit[i] = TRUE;
			EnQueue(&Q, i);
			while(!QueueEmpty(Q))
			{
				char j;
				DeQueue(&Q, &j);	
				int k = 0;
				for(; k < G.numVertexes; k ++)
				{
					if(G.arc[j][k] != 0 && visit[k] != TRUE)
					{
						printf("%c ", G.vexs[k]);
						visit[k] = TRUE;
						EnQueue(&Q, k); 
					}
				}
			}	
		}	
	} 
	
   
   
}
/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */


int main(void)

{

	MGraph G;

	CreateMGraph(&G);

	printf("广度遍历：");

	BFSTraverse(G);

	printf("\n");

	return 0;

}


/* PRESET CODE END - NEVER TOUCH CODE ABOVE */
14. 2023级-04班-期末复习题-图的遍历-深度优先遍历连通图-邻接矩阵法
//编写DFSTraverse函数

/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */


#include "stdio.h"    

#include "stdlib.h"   


#include "math.h"  

#include "time.h"


#define OK 1

#define ERROR 0

#define TRUE 1

#define FALSE 0


typedef int Status;	/* Status是函数的类型,其值是函数结果状态代码，如OK等 */

typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */


typedef char VertexType; /* 顶点类型 */

typedef int EdgeType; /* 边上的权值 */


#define MAXSIZE 9 /* 存储空间初始分配量 */

#define MAXEDGE 15

#define MAXVEX 9


typedef struct

{

	VertexType vexs[MAXVEX]; /* 顶点表 */

	EdgeType arc[MAXVEX][MAXVEX];/* 邻接矩阵，可看作边表 */

	int numVertexes, numEdges; /* 图中当前的顶点数和边数 */

}MGraph;


void CreateMGraph(MGraph* G)

{

	int i, j;


	G->numEdges = 15;

	G->numVertexes = 9;


	/* 读入顶点信息，建立顶点表 */

	G->vexs[0] = 'A';

	G->vexs[1] = 'B';

	G->vexs[2] = 'C';

	G->vexs[3] = 'D';

	G->vexs[4] = 'E';

	G->vexs[5] = 'F';

	G->vexs[6] = 'G';

	G->vexs[7] = 'H';

	G->vexs[8] = 'I';



	for (i = 0; i < G->numVertexes; i++)/* 初始化图 */

	{

		for (j = 0; j < G->numVertexes; j++)

		{

			G->arc[i][j] = 0;

		}

	}


	G->arc[0][1] = 1;

	G->arc[0][5] = 1;


	G->arc[1][2] = 1;

	G->arc[1][8] = 1;

	G->arc[1][6] = 1;


	G->arc[2][3] = 1;

	G->arc[2][8] = 1;


	G->arc[3][4] = 1;

	G->arc[3][7] = 1;

	G->arc[3][6] = 1;

	G->arc[3][8] = 1;


	G->arc[4][5] = 1;

	G->arc[4][7] = 1;


	G->arc[5][6] = 1;


	G->arc[6][7] = 1;



	for (i = 0; i < G->numVertexes; i++)

	{

		for (j = i; j < G->numVertexes; j++)

		{

			G->arc[j][i] = G->arc[i][j];

		}

	}


}


/* PRESET CODE END - NEVER TOUCH CODE ABOVE */

void DFSTraverse(MGraph G)
{
   /*请补充代码*/
   int i = 0;
   int visit[G.numVertexes + 1];
   for(i = 0; i < G.numVertexes; i++)
   {
   		visit[i] = FALSE;
	} 
	int stack[MAXVEX];
	int top = -1;
	for(i = 0 ;i < G.numVertexes ;i ++)
	{
		if(visit[i] == FALSE)
		{			
			stack[++top] = i;
			while(top != -1)
			{
				int temp = stack[top--];
				if(visit[temp] == FALSE)
				{
					printf("%c ",G.vexs[temp]);
					visit[temp] = TRUE;
					int k = 0;
					for(k = G.numVertexes - 1; k >= 0 ; k --)
					{
						if(G.arc[temp][k] != 0 && visit[k] == FALSE)
						{
							stack[++top] = k;
						}
					}
				}
			}
		}
	 } 
}
/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */


int main(void)

{

	MGraph G;

	CreateMGraph(&G);

	printf("深度遍历：");

	DFSTraverse(G);

	printf("\n");

	return 0;

}


/* PRESET CODE END - NEVER TOUCH CODE ABOVE */
15. 2023-期末复习-图的广度优先搜索-邻接表法
/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */


#include "stdio.h"

#include "stdlib.h"


#define OK 1

#define ERROR 0

#define TRUE 1

#define FALSE 0



#define MAXSIZE 8 /* 存储空间初始分配量 */

#define MAXEDGE 9 /* 存储空间初始分配量 */


#define MAXVEX 8


typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */


typedef struct EdgeNode//边表节点

{

    int adjvex;//存储该顶点对应的下标

    struct EdgeNode *next;//指向该顶点的下一个邻接点

}EdgeNode;


typedef struct VertexNode//顶点表结点

{

    char data;//顶点

    EdgeNode *firstedge;//边表头指针

}VertexNode;


typedef struct//图的邻接表存储结构

{

    VertexNode adjList[MAXVEX];//有4个VertexNode这种类型的顶点，定义一个数组adjList[4]，每个元素是VertexNode类型

    int numVertexes,numEdges;//图中顶点数和边数，这里是4,5

}GraphAdjList;


void CreateALGraph(GraphAdjList *p)//无向图的邻接表创建

{

int k;

int i;

int j;

    GraphAdjList *Gp=(GraphAdjList *)malloc(sizeof(GraphAdjList));

    EdgeNode *pe;

	printf("请输入顶点数和边数:\n");

	scanf("%d %d",&(Gp->numVertexes),&(Gp->numEdges));

	printf("请输入顶点数的数据:\n");

	getchar();

    for (k = 0; k < Gp->numVertexes; k++)

{

		scanf("%c",&(Gp->adjList[k].data));

		getchar();

Gp->adjList[k].firstedge = NULL;//将边表头指针指向NULL，即置为0

    }

	printf("请输入边的数据:\n");

for (k = 0; k <  Gp->numEdges; k++)//建立边表

{

		scanf("%d %d",&i,&j);

		getchar();

        pe = (EdgeNode *)malloc(sizeof(EdgeNode));

        pe->adjvex = j;// 邻接序号为j

        pe->next = Gp->adjList[i].firstedge;//将pe的指针指向当前顶点指向的结点

        Gp->adjList[i].firstedge = pe;//将当前顶点的指针指向pe


        pe = (EdgeNode *)malloc(sizeof(EdgeNode));

        pe->adjvex = i;

        pe->next = Gp->adjList[j].firstedge;

        Gp->adjList[j].firstedge = pe;//无序图重复上面步骤

    }

*p=*Gp;

}


/* 用到的队列结构与函数********************************** */


/* 循环队列的顺序存储结构 */

typedef struct

{

	int data[MAXSIZE];
	
	int front;    	/* 头指针 */
	
	int rear;/* 尾指针，若队列不空，指向队列尾元素的下一个位置 */

}Queue;


/* 初始化一个空队列Q */

Status InitQueue(Queue* Q)

{

	Q->front = 0;

	Q->rear = 0;

	return  OK;

}


/* 若队列Q为空队列,则返回TRUE,否则返回FALSE */

Status QueueEmpty(Queue Q)

{

	if (Q.front == Q.rear) /* 队列空的标志 */
	
		return TRUE;
	
	else
		
		return FALSE;
	
}


/* 若队列未满，则插入元素e为Q新的队尾元素 */

Status EnQueue(Queue* Q, char e)

{

	if ((Q->rear + 1) % MAXSIZE == Q->front)/* 队列满的判断 */
	
		return ERROR;

	Q->data[Q->rear] = e;/* 将元素e赋值给队尾 */

	Q->rear = (Q->rear + 1) % MAXSIZE;/* rear指针向后移一位置， */

/* 若到最后则转到数组头部 */
	
	return  OK;

}


/* 若队列不空，则删除Q中队头元素，用e返回其值 */

Status DeQueue(Queue* Q, int* e)

{

	if (Q->front == Q->rear)/* 队列空的判断 */
		
		return ERROR;
	
	*e = Q->data[Q->front];/* 将队头元素赋值给e */
	
	Q->front = (Q->front + 1) % MAXSIZE;/* front指针向后移一位置， */
	
	/* 若到最后则转到数组头部 */
	
	return  OK;

}

/* ****************************************************** */


/* PRESET CODE END - NEVER TOUCH CODE ABOVE */

/*
先打印再入队，这样就少了一次条件判断，而且那个条件判断不好加，会影响后面的循环。所以就采用这种方式
*/

void BFSTraverse(GraphAdjList G)
{
   /*请补充代码*/
   int i , j ;
   int visit[MAXVEX] ;
   for(i = 0; i < MAXVEX; i++)
   {
   		visit[i] = FALSE;
   }
   Queue Q;
   InitQueue(&Q);
   for(i = 0; i < G.numVertexes; i ++)
   {
   		if(visit[i] == FALSE)
   		{
   			printf("%c ",G.adjList[j].data);
			visit[j] = TRUE;
   			EnQueue(&Q, i);
			while(!QueueEmpty(Q))
			{
				int j;
				DeQueue(&Q, &j);
				EdgeNode *p = G.adjList[j].firstedge;
                while (p)
                {
                    if (!visit[p->adjvex])
                    {
                        visit[p->adjvex] = TRUE;
                        printf("%c ", G.adjList[p->adjvex].data);
                        EnQueue(&Q, p->adjvex);
                    }
                    p = p->next;
                }
							
			}	
		}
   }
   
}
/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */


int main(void)

{

    GraphAdjList p;

    CreateALGraph(&p);

    BFSTraverse(p);//输出的遍历顺序是ADCB

	printf("\n");

    return 0;

}


/* PRESET CODE END - NEVER TOUCH CODE ABOVE */
16. 2023级-04班-期末复习题-图的深度优先搜索-邻接表法
/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */



#include "stdio.h"

#include "stdlib.h"



typedef struct EdgeNode//边表节点

{

   int adjvex;//存储该顶点对应的下标

   struct EdgeNode *next;//指向该顶点的下一个邻接点

}EdgeNode;



typedef struct VertexNode//顶点表结点

{

   char data;//顶点

   EdgeNode *firstedge;//边表头指针

}VertexNode;



typedef struct//图的邻接表存储结构

{

   VertexNode adjList[4];//有4个VertexNode这种类型的顶点，定义一个数组adjList[4]，每个元素是VertexNode类型

   int numVertexes,numEdges;//图中顶点数和边数，这里是4,5

}GraphAdjList;



void CreateALGraph(GraphAdjList *p)//无向图的邻接表创建

{

int k;

int i;

int j;

   GraphAdjList *Gp=(GraphAdjList *)malloc(sizeof(GraphAdjList));

   EdgeNode *pe;

printf("请输入顶点数和边数:\n");

scanf("%d %d",&(Gp->numVertexes),&(Gp->numEdges));

printf("请输入顶点数的数据:\n");

getchar();

   for (k = 0; k < Gp->numVertexes; k++)

{

scanf("%c",&(Gp->adjList[k].data));

getchar();

Gp->adjList[k].firstedge = NULL;//将边表头指针指向NULL，即置为0

   }

printf("请输入边的数据:\n");

for (k = 0; k <  Gp->numEdges; k++)//建立边表

{

scanf("%d %d",&i,&j);

getchar();

       pe = (EdgeNode *)malloc(sizeof(EdgeNode));

       pe->adjvex = j;// 邻接序号为j

       pe->next = Gp->adjList[i].firstedge;//将pe的指针指向当前顶点指向的结点

       Gp->adjList[i].firstedge = pe;//将当前顶点的指针指向pe



       pe = (EdgeNode *)malloc(sizeof(EdgeNode));

       pe->adjvex = i;

       pe->next = Gp->adjList[j].firstedge;

       Gp->adjList[j].firstedge = pe;//无序图重复上面步骤

   }

*p=*Gp;

}



/* PRESET CODE END - NEVER TOUCH CODE ABOVE */

void DFSTraverse(GraphAdjList G)
{
   /*请补充代码*/
   int stack[G.numVertexes];
   int top = -1;
   int visit[G.numVertexes];
   int i;
   for(i = 0 ;i <G.numVertexes ;i ++)
   {
   		visit[i] = 0;
   }
   for(i = 0; i < G.numVertexes ;i ++)	
   {
   		if(visit[i] == 0){
   			printf("%c ", G.adjList[i].data);
   			visit[i] = 1;
   			stack[++top] = i;
   			while(top != -1){
   				int u = stack[top --];
   				EdgeNode *p = G.adjList[u].firstedge;
				if(visit[p->adjvex] == 0){
					printf("%c ", G.adjList[p->adjvex].data);
					visit[p->adjvex] = 1;
					stack[++top] = p->adjvex;
				   }
			   }
		   }
	} 
   
   
}
/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */



int main(void)

{

   GraphAdjList p;

   CreateALGraph(&p);

   DFSTraverse(p);//输出的遍历顺序是ADCB
	
	printf("\n");

   return 0;

}



/* PRESET CODE END - NEVER TOUCH CODE ABOVE */
17. 2023-期末复习-图的连通性判断和连通分量计算
/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */


#include "stdio.h"    

#include "stdlib.h"   


#include "math.h"  

#include "time.h"


#define OK 1

#define ERROR 0

#define TRUE 1

#define FALSE 0


typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */

typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */


typedef char VertexType; /* 顶点类型 */

typedef int EdgeType; /* 边上的权值 */


#define MAXSIZE 9 /* 存储空间初始分配量 */

#define MAXEDGE 4

#define MAXVEX 6


typedef struct

{

VertexType vexs[MAXVEX]; /* 顶点表 */

EdgeType arc[MAXVEX][MAXVEX];/* 邻接矩阵，可看作边表 */

int numVertexes, numEdges; /* 图中当前的顶点数和边数 */

}MGraph;


int count =0;//连通分量的个数，全局变量


void CreateMGraph(MGraph* G)

{

int i, j;


	G->numEdges = 4;

	G->numVertexes = 6;


/* 读入顶点信息，建立顶点表 */

	G->vexs[0] = 'A';

	G->vexs[1] = 'B';

	G->vexs[2] = 'C';

	G->vexs[3] = 'D';

	G->vexs[4] = 'E';

	G->vexs[5] = 'F';



for (i = 0; i < G->numVertexes; i++)/* 初始化图 */

{

for (j = 0; j < G->numVertexes; j++)

{

			G->arc[i][j] = 0;

}

}


	G->arc[0][1] = 1;

	G->arc[0][5] = 1;

	G->arc[1][2] = 1;

	G->arc[3][4] = 1;



for (i = 0; i < G->numVertexes; i++)

{

for (j = i; j < G->numVertexes; j++)

{

			G->arc[j][i] = G->arc[i][j];

}

}


}


/* PRESET CODE END - NEVER TOUCH CODE ABOVE */

int DFSTraverse(MGraph G)
{
   /*请补充代码*/
	int i;
	int stack[G.numVertexes];
	int top = -1;
	int visit[G.numVertexes];
	for(i = 0;i < G.numVertexes ;i ++)
	{
		visit[i] = 0;
	}
	for(i = 0;i < G.numVertexes;i ++)
	{
		if(visit[i] == 0)
		{
			visit[i] = 1;
			stack[++top] = i;
			while(top != -1){
				int u = stack[top --];
				int k = 0;
				for(k = 0;k < G.numVertexes;k ++)
				{
					if(G.arc[u][k] != 0 && visit[k] == 0)
					{
						visit[k] = 1;
						stack[++top] = k;
					}
				}
			}  
			count++;
		}
	}
	return count > 1 ? 0 : 1 ;
}
/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */


int main(void)

{

MGraph G;

int connect;

CreateMGraph(&G);

	connect=DFSTraverse(G);

if(connect)

{

		printf("该无向图全连通:\n");

}

else

{

		printf("该无向图不是全连通,其连通分量个数为：%d\n",count);

}

return 0;

}


/* PRESET CODE END - NEVER TOUCH CODE ABOVE */
18. 2023级-04班-期末复习题-判断图的顶点连通性
/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */

#include "stdio.h"

#include "stdlib.h"

#include "string.h"

#define TRUE 1

int visited[4];

typedef struct EdgeNode//边表节点

{

   int adjvex;//存储该顶点对应的下标

   struct EdgeNode *next;//指向该顶点的下一个邻接点

}EdgeNode;

typedef struct VertexNode//顶点表结点

{

   char data;//顶点

   EdgeNode *firstedge;//边表头指针

}VertexNode;

typedef struct//图的邻接表存储结构

{

   VertexNode adjList[4];//有4个VertexNode这种类型的顶点，定义一个数组adjList[4]，每个元素是VertexNode类型

   int numVertexes,numEdges;//图中顶点数和边数，这里是4,5

}GraphAdjList;

void CreateALGraph(GraphAdjList *p)//无向图的邻接表创建

{

int k;

int i;

int j;

   GraphAdjList *Gp=(GraphAdjList *)malloc(sizeof(GraphAdjList));

   EdgeNode *pe;

printf("请输入顶点数和边数:\n");

scanf("%d %d",&(Gp->numVertexes),&(Gp->numEdges));

printf("请输入顶点数的数据:\n");

getchar();

   for (k = 0; k < Gp->numVertexes; k++)

{

scanf("%c",&(Gp->adjList[k].data));

getchar();

Gp->adjList[k].firstedge = NULL;//将边表头指针指向NULL，即置为0

visited[k]=0;

}

printf("请输入边的数据:\n");

for (k = 0; k <  Gp->numEdges; k++)//建立边表

{

scanf("%d %d",&i,&j);

getchar();

       pe = (EdgeNode *)malloc(sizeof(EdgeNode));

       pe->adjvex = j;// 邻接序号为j

       pe->next = Gp->adjList[i].firstedge;//将pe的指针指向当前顶点指向的结点

       Gp->adjList[i].firstedge = pe;//将当前顶点的指针指向pe

       pe = (EdgeNode *)malloc(sizeof(EdgeNode));

       pe->adjvex = i;

       pe->next = Gp->adjList[j].firstedge;

       Gp->adjList[j].firstedge = pe;//无序图重复上面步骤

   }

*p=*Gp;

}

int LocateVex(GraphAdjList G,char u)

{ // 初始条件: 图G存在,u和G中顶点有相同特征

  // 操作结果: 若G中存在顶点u,则返回该顶点在图中位置;否则返回-1

  int i;

  for(i=0;i < G.numVertexes;i ++)
  {
  		if(G.adjList[i].data == u)	return i;
  }

    return -1;

}

int NextAdjVex(GraphAdjList G,int v,int w)

{ // 初始条件: 图G存在,v是G中某个顶点,w是v的邻接顶点

  // 操作结果: 返回v的(相对于w的)下一个邻接顶点的序号。

  // 若w是v的最后一个邻接点,则返回-1

  EdgeNode *p;

  p=G.adjList[v].firstedge;

  while(p&&p->adjvex!=w)  

  {

  p=p->next;

  }

  if(!p||!p->next)  //没找到w或w是最后一个邻接点

    return -1;

  else   //p->adjvex==w

    return p->next->adjvex;

}

/* PRESET CODE END - NEVER TOUCH CODE ABOVE */

//补充函数代码

void isConnected(GraphAdjList G, int v1, int v2, int *flag)
{
	if(v1 == v2)	
	{
		*flag = TRUE;
		return ;
	}
	EdgeNode *p;
	p=G.adjList[v1].firstedge;
	while(p)
	{
		int res = NextAdjVex(G, p->adjvex, v2);
		if(res == -1)
			p = p->next;
		else
		{
			*flag = 1;
			return;
		}
	}	
}



/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */

int main(void)

{

   GraphAdjList p;

char u1;

char u2;

int v1;

int v2;

int flag=0;

   CreateALGraph(&p);

printf("输入两个顶点:\n");

scanf("%c %c",&u1,&u2);

v1=LocateVex(p,u1);

v2=LocateVex(p,u2);

isConnected(p,v1,v2,&flag);

if(flag)

{

printf("顶点相通\n");

}

else

{

printf("顶点不相通\n");

}

   return 0;

}

/* PRESET CODE END - NEVER TOUCH CODE ABOVE */
19. 2023级-04班-期末复习题-图的回路判断
/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */



#include "stdio.h"    

#include "stdlib.h"  



#include "math.h"  

#include "time.h"



#define OK 1

#define ERROR 0

#define TRUE 1

#define FALSE 0



typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */

typedef char VertexType; /* 顶点类型 */

typedef int EdgeType; /* 边上的权值 */


#define MAXSIZE 9 /* 存储空间初始分配量 */

#define MAXEDGE 6

#define MAXVEX 6

int visited[MAXVEX]; /* 访问标志的数组 */ 
int parent[MAXVEX]; /*父链接结点*/


typedef struct

{

VertexType vexs[MAXVEX]; /* 顶点表 */

EdgeType arc[MAXVEX][MAXVEX];/* 邻接矩阵，可看作边表 */

int numVertexes, numEdges; /* 图中当前的顶点数和边数 */

}MGraph;



int count =0;//连通分量的个数，全局变量



void CreateMGraph(MGraph* G)

{

int i, j;



G->numEdges = MAXEDGE;

G->numVertexes = MAXVEX;



/* 读入顶点信息，建立顶点表 */

G->vexs[0] = 'A';

G->vexs[1] = 'B';

G->vexs[2] = 'C';

G->vexs[3] = 'D';

G->vexs[4] = 'E';

G->vexs[5] = 'F';





for (i = 0; i < G->numVertexes; i++)/* 初始化图 */

{

for (j = 0; j < G->numVertexes; j++)

{

G->arc[i][j] = 0;

}

}



G->arc[0][1] = 1;

G->arc[0][4] = 1;

G->arc[0][5] = 1;

G->arc[1][2] = 1;

G->arc[2][3] = 1;

G->arc[3][4] = 1;





for (i = 0; i < G->numVertexes; i++)

{

for (j = i; j < G->numVertexes; j++)

{

G->arc[j][i] = G->arc[i][j];

}

}



}



int LocateVex(MGraph G, VertexType e)

{

// 初始条件:图G存在,u和G中顶点有相同特征

// 操作结果:若G中存在顶点u,则返回该顶点在图中位置;否则返回-1

//补充函数
	
	int i = 0;
	for(;i < G.numVertexes;i ++)
	{
		if(G.vexs[i] == e)	return i;
	 } 
	 return -1;

}


Status FindCycle(MGraph G, int v0) {
    int i, u, v;

    for (i = 0; i < G.numVertexes; i++) 
    {
        visited[i] = 0; // Initialize all vertices as not visited
        parent[i] = -1; // Initialize parent array
    }

    for (u = 0; u < G.numVertexes; u++) 
    {
        if (!visited[u]) 
        { // Don't recur for already visited vertices
            int stack[MAXVEX], top = -1;
            stack[++top] = u; // Push the current source node

            while (top != -1) 
            {
                v = stack[top--]; // Pop a vertex from stack
                visited[v] = 1; // Mark the node as visited

                for (i = 0; i < G.numVertexes; i++) 
                {
                    if (G.arc[v][i]) 
                    { // If there is an edge
                        if (!visited[i]) 
                        { // If the adjacent node is not visited
                            stack[++top] = i; // Push the adjacent node onto the stack
                            parent[i] = v; // Mark the parent of the adjacent node
                        } 
                        else if (i != parent[v]) 
                        { // If an adjacent is visited and not parent of current vertex
                            return TRUE; // Cycle detected
                        }
                    }
                }
            }
        }
    }
    return FALSE; // If no cycle is detected
}


/* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */



int main(void)

{

MGraph G;

int flag=0;

int i;

CreateMGraph(&G);

for(i=0;i< MAXVEX ;i++)

{

visited[i]=0;

parent[i]=-1;

}

flag=FindCycle(G,0);

if(!flag)

{

printf("图没有回路\n");

}

else

{

printf("图有回路\n");

}

return 0;

}



/* PRESET CODE END - NEVER TOUCH CODE ABOVE */
li361128
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
fpga期末考题库_FPGA期末复习题(答案)知识点+题型.doc
weixin_29657209的博客
12-24 2895
FPGA期末复习题(答案)知识点题型填空题：?1、?FPGA结构一般分为三部分：可编程逻辑块(CLB)、可编程I/O模块和可编程内部连线。??CPLD的内部连线为连续式布线互连结构，任意一对输入、输出端之间的延时是固定?；FPGA的内部连线为分段式布线互连结构，各功能单元间的延时不定(不可预测)。??大规模可编程器件主要有CPLD和FPGA两类，其中CPLD通过可编程乘积项逻辑实现其逻辑功能。?基...
期末复习题
Asavakitln的博客
09-29 2013
1：多选必考 是计算机系统中最大的一块电路板，是计算机的核心部件。 A、硬盘 B、主板 C、软盘 D、CPU 参考答案：B 2：判断必考 主板将计算机内部器件连接起来，形成一个完整的硬件系统。 参考答案：错误 3：多选 以下哪些因素是选配主板时应该考虑的。 A、尽可能选用业界知名厂商质量有保障的产品 B、根据自己的需要，选择CPU的型号规格 C、尽可能选择便宜的 D、考虑电脑和主板将来的扩展能力 ...
Android期末复习篇_8章节练习题附答案
xiaosi的博客
06-23 1万+
说明 Android移动应用开发章节练习题，注意 此答案并非标准答案，仅供期末复习参考。 加粗题目为强调题目 目录 第一章-安卓基础入门 第二章-安卓常见页面布局 第三章-安卓常见页面控件 第四章-安卓程序活动单元Activity 第五章-安卓数据存储 第六章-内容提供者 第七章-广播 一、第一章-安卓基础入门 Android安装包文件简称APK，其后缀名是（A） • A、apk • B、exe • C、txt • D、app Android 工程中存放各种程序资源的目录是（C） • A、src
人工智能导论期末复习题
热门推荐
xtcc的博客
03-05 6万+
文章目录@[toc]期末复习题一一、选择题二、填空题三、判断题四、简答题期末复习题二一、选择题二、填空题三、判断题四、简答题 期末复习题一 一、选择题 1.【多选题】在卷积神经网络中，常用的池化方法有 （ABC） A. 最大池化法 B. 平均池化法 C. 概率池化法 D. 最小池化法 2.【单选题】本原问题所对应的节点称为 （B） A. 端节点 B. 终叶节点 C. 子节点 D. 父节点 3.【单选题】支持向量机算法属于 （B） A. 决策树学习 B. 统计学习 C. 集成学习 D.记忆学习 4.【单选题
Android期末复习题库
qq_44111805的博客
01-15 3万+
一、单选题 1、在程序中输出debug调试日志信息，我们应该使用方法（） A、Log.i(tag,msg) B、Log.e(tag,msg) C、Log.d(tag,msg) D、Log.w(tag,msg) 2、如果在帧布局FrameLayout中放入三个所有属性值相同按钮，能够在屏幕上显示的是（） A、最后一个被添加的按钮 B、第一个被添加的按钮 C、第二个被动添加的按钮 D、三个按钮都能显示 3、在使用输入框EditText控件时，当其文本内容为空的时候，做出一些提示，那么使用的属性是（） A、an
C语言课件+期中期末考试题+平时作业+期末复习题_北交大
11-18
C语言课件+期中期末考试题+平时作业+期末复习题_北交大 C语言课件+期中期末考试题+平时作业+期末复习题_北交大 C语言课件+期中期末考试题+平时作业+期末复习题_北交大
机器学习期末复习题及答案
03-19
"机器学习期末复习题及答案" 机器学习是人工智能的一个分支，涉及到计算机科学、统计学、优化方法、信息论等多个领域。以下是机器学习的知识点总结： 单项选择题 1. 机器学习把数据集分成训练集和测试集，用于...
ASP.NET期末复习题
12-11
ASP.NET期末复习题知识点总结 以下是根据给定的文件信息，总结出的相关知识点： 一、ASP.NET 基础 * ASPX 网页的代码储存模式有两种：单一模式和代码隐藏模式 * ASP.NET 窗体文件的扩展名为.aspx * ASP.NET 支持...
PHP期末复习题.pdf
01-08
PHP期末复习题 PHP基础知识点 1. GET和POST请求方式：GET方式是指在浏览器地址栏中输入数据，POST方式是指通过HTML表单提交数据的方式。在表单中可使用GET或POST方式提交数据。 2. NetBeans注册MySQL服务器：在...
西科大模电、电磁波、计网期末复习题
05-26
西科大模电、电磁波、计网期末复习题西科大模电、电磁波、计网期末复习题西科大模电、电磁波、计网期末复习题西科大模电、电磁波、计网期末复习题西科大模电、电磁波、计网期末复习题西科大模电、电磁波、计网期末...
算法日记day 45（单调栈之每日温度|接雨水）
m0_74980681的博客
08-22 374
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 237
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
C语言——函数递归
2406_83392683的博客
08-18 397
递归是一种解决问题的方法，在C语言中，就是。但是，如果递归无限地进行下去，就会出现栈溢出，上述就是一个典型例子。
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 645
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
算法025：前缀和
最新发布
m0_62319039的博客
08-22 143
算法025：前缀和
noip2001数的划分
no_play_no_games的博客
08-18 204
将整数n分成k份，且每份不能为空，任意两份不能相同(不考虑顺序)。例如：n=7，k=3，下面三种分法被认为是相同的。1，1，5;1，5，1;5，1，1;问有多少种不同的分法。
24/8/18算法笔记 目标导向强化学习
yyyy2711的博客
08-18 487
初始化DDPG模型data = {'over':[],#Data采样函数#采样结果sample = {'over':[],#采样N个数据#随机一局游戏#随机游戏中的一步，这里除了最后一步#提取数据#设置fake goal#随机选择step后面的某一步#以后面某个步的状态为一个伪的终点，也就是希望先走到这里再说#求二范数mod = [#再自己重新计算reward和over#以伪终点构建新的state#计算最后10个数据reward_sum的值。
湖北师范大学-Python程序设计-3.1 中国古代数学问题(project)
柠檬喝汽水的博客
08-19 710
唐朝时，一斗酒的斗所采用的度量是小斗，也就是4斤，当时一斤取值范围大约在500多到600克左右，换算一下可知唐朝一斗酒的重量取值范围在2000克到2400克左右。有一座八层宝塔，每一层都有一些琉璃灯，每一层的灯数都是上一层的二倍，已知共有 765 盏琉璃灯，计算并输出每层各有多少盏琉璃灯。输出不超过 n 且满足条件的物品个数 m，如果有多个解，则分行输出，每行一个解；第二行输出 2 个浮点数，依次为小鼠和大鼠打洞的距离，单位为尺，保留小数点后 1 位数字。一个浮点数 f，表示李白的酒壶原来有 f 斗酒。
最小区间00
青釉Oo的博客
08-21 291
最小区间
java期末考试复习题_java期末考试复习试题
06-21
这份Java期末考试复习题包含了ch01-ch18的内容，是为了帮助学生复习Java知识点而准备的。其中包括了一些重点和需要掌握的知识点，例如Java SE的表示、JVM的含义等。在这份复习题中，Java SE表示Java标准版，而JVM的含义是Java虚拟机。这份复习题可以帮助学生检验自己对Java知识点的掌握情况，同时也可以帮助他们更好地备战期末考试。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值