数据结构 C 图的存储结构和两种遍历

最新推荐文章于 2024-04-29 17:23:39 发布
最新推荐文章于 2024-04-29 17:23:39 发布
阅读量307 收藏 2
点赞数 2
文章标签： 数据结构 c语言 宽度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66967137/article/details/125070419
版权

图的存储结构

邻接矩阵

typedef struct graph{
    int** connection;//邻接矩阵（实质是二维数组） 
    int numNodes;//矩阵阶数
}*graphPtr; 

优点

  • 便于判断两个顶点之间是否有边，即根据A[i][j]=0或1来判断。
  • 便于计算各个顶点的度。对于无向图，邻接矩阵第i行元素之和就是顶点i的度；对于有向图，第i行元素之和就是顶点i的出度，第1列元素之和就是顶点i的入度。

缺点

  • 不便于增加和删除顶点。
  • 不便于统计边的数目，需要扫描邻接矩阵所有元素才能统计完毕，时间复杂度为O(n^2)。
  • 空间复杂度高。如果是有向图，n个顶点需要n^2个单元存储边。如果是无向图，因其邻接矩阵是对称的，所以对规模较大的邻接矩阵可以采用压缩存储的方法，仅存储下三角(或上三角)的元素，这样需要n(n- 1)/2个单元即可。但无论以何种方式存储，邻接矩阵表示法的空间复杂度均为O(n^2)，这对于稀疏图而言尤其浪费空间。                                                                                                                                                                                               

邻接表

邻接表：实质上是邻接矩阵的压缩存储

typedef struct AdjacencyNode{//邻接结点边表 
    int subscript;//邻接点域
    struct AdjacencyNode* next;//链域 
}AdjacencyNode,*AdjacentNodePtr;
typedef struct AdjacencyList{//邻接表顶点表 
    int numNodes;//结点数 
    struct AdjacencyNode* header;//一维数组
}AdjacencyList,*AdjacencyListPtr;

优点

  • 便于增加和删除顶点。
  • 便于统计边的数目，按顶点表顺序扫描所有边表可得到边的数目，时间复杂度为O(n+ e)。
  • 空间效率高。对于一个具有n个顶点e条边的图G,若G是无向图，则在其邻接表表示中有n个顶点表结点和2e个边表结点;若G是有向图，则在它的邻接表表示或逆邻接表表示中均有n个顶点表结点和e个边表结点。因此，邻接表或逆邻接表表示的空间复杂度为O(n+e),适合表示稀疏图。对于稠密图，考虑到邻接表中要附加链域，因此常采取邻接矩阵表示法。

缺点

  • 不便于判断顶点之间是否有边，要判定vi和yj之间是否有边，就需扫描第i个边表，最坏情况下要耗费O(n)时间。
  • 不便于计算有向图各个顶点的度。对于无向图，在邻接表表示中顶点vi的度是第i个边表中的结点个数。在有向图的邻接表中，第i个边表上的结点个数是顶点vi的出度，但求vi的入度较困难，需遍历各顶点的边表。若有向图采用逆邻接表表示，则与邻接表表示相反，求顶点的入度容易，而求顶点的出度较难。 

图的遍历

图的两种遍历：深度优先搜索(DFS)和广度优先搜索(WFS)，两种遍历算法的实现都需要使用访问标志数组visitedPtr[i]来标记当前结点i是否已经被访问

深度优先搜索(DFS)

DFS:使用了访问标志数组和递归

void DFS(graphPtr paraGraphPtr, int paraNode/*结点标号*/){
    int i;
    visitedPtr[paraNode]=1;//将paraNode标记为1，表示该结点已经访问过 
    printf("%d\t",paraNode);
    for(i=0;i<paraGraphPtr->numNodes;i++){
        if(!visitedPtr[i]){//如果有未被访问的结点 
            if(paraGraphPtr->connection[paraNode][i]){//如果有paraNode的邻接点i(即[paraNode][i]为1) 
                DFS(paraGraphPtr,i);//对paraNode的尚未被访问的邻接点i递归调用DFS搜索 
            }//of if
        }//of if
    }//of for
}//of DFS

广度优先搜索(WFS) 

WFS: 使用了访问标志数组和队列

void WFS(graphPtr paraGraphPtr, int paraStart/**/){
    //初始化辅助队列
    //printf("Begin to initialize queue.\r\n");
    QueuePtr tempQueue=initQueue();
    enqueue(tempQueue,paraStart);
    //printf("paraStart enqueued.\r\n");
    visitedPtr[paraStart]=1;
    printf("%d\t",paraStart);
    
    int i,j,tempNode;
    i=0;//i计数 
    while(!isQueueEmpty(tempQueue)){//队列不为空 
        tempNode=dequeue(tempQueue);//tempNode接收出队元素 
        //printf("tempNode=%d\r\n",tempNode);
        visitedPtr[tempNode]=1;//标记tempNode已经被访问 
        i++;//计数 
        for(j=0;j<paraGraphPtr->numNodes;j++){//遍历图寻找没有被访问且与tempNode有边的结点 
            if( visitedPtr[j]==0 && paraGraphPtr->connection[tempNode][j]==1){
                printf("%d\t",j);
                visitedPtr[j]=1;
                enqueue(tempQueue,j);
            }
        } 
        //printf("i=%d",i);
    }
    //printf("i=%d",i);
} 

使用邻接矩阵的两种图遍历算法的完整代码： 

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h> 
#define QUEUE_SIZE 10//队列空间大小 
int* visitedPtr;//记录结点是否已被访问 
typedef struct graphNodeQueue{
	int* node;
	int front;
	int rear; 
}graphNodeQueue,*QueuePtr;
/*初始化队列*/ 
QueuePtr initQueue(){
	QueuePtr resultPtr=(QueuePtr)malloc(sizeof(struct graphNodeQueue));
	resultPtr->node=(int*)malloc(QUEUE_SIZE*sizeof(int));
	resultPtr->front=0;
	resultPtr->rear=1;
	return resultPtr;
}
/*判断队列是否为空*/
bool isQueueEmpty(QueuePtr paraQueue){
	if((paraQueue->front+1)%QUEUE_SIZE==paraQueue->rear){
		return true;
	}
	return false;
}
/*结点入队*/
void enqueue(QueuePtr paraQueue,int paraNode){
	//判断队满
	if((paraQueue->rear+1)%QUEUE_SIZE==paraQueue->front%QUEUE_SIZE){//注意paraQueue->front也要%QUEUE_SIZE
		printf("Error,tring to enqueue %d,but queue full.\r\n");
		return;
	} 
	//让结点入队（入尾指针处） 
	paraQueue->node[paraQueue->rear]=paraNode;
	//更新队列尾指针 
	paraQueue->rear= (paraQueue->rear+1)%QUEUE_SIZE;
}
/*结点出队*/
int dequeue(QueuePtr paraQueue){
	//判断队空 
	if(isQueueEmpty(paraQueue)){
		printf("Error,empty queue.\r\n");
		return -1;
	}
	paraQueue->front=(paraQueue->front+1)%QUEUE_SIZE;
	//printf("dequeue %d ends.\r\n", paraQueue->node[paraQueue->front]);
	return paraQueue->node[paraQueue->front];
}
/*图的存储表示*/
typedef struct graph{
	int** connection;//邻接矩阵 
	int numNodes;//矩阵阶数 
}*graphPtr; 	
/*初始化图*/
graphPtr initGraph(int paraSize,int** paraData){
	int i,j;
	graphPtr resultPtr=(graphPtr)malloc(sizeof(struct graph));
	resultPtr->connection=(int**)malloc(paraSize*sizeof(int*));
	resultPtr->numNodes=paraSize; 
	for(i=0;i<paraSize;i++){
		resultPtr->connection[i]=(int*)malloc(paraSize*sizeof(int));
		for(j=0;j<paraSize;j++){
			//printf("i=%d,j=%d.\r\n",i,j);
			resultPtr->connection[i][j]=paraData[i][j];
			//printf("i=%d,j=%d,connection[i][j]=%d.\r\n",i,j,resultPtr->connection[i][j]);
		}
	}
	return resultPtr;
}
/*初始化visitedPtr数组为0*/
void initVisitedPtr(graphPtr paraGraphPtr){
	visitedPtr=(int*)malloc(paraGraphPtr->numNodes*sizeof(int));
	int i;
	for(i=0;i<paraGraphPtr->numNodes;i++){
		visitedPtr[i]=0;
		//printf("visitedPtr[%d]=%d\r\n",i,visitedPtr[i]);
	}
}
/*深度优先搜索*/ 
void DFS(graphPtr paraGraphPtr, int paraNode/*结点标号*/){
	int i;
	visitedPtr[paraNode]=1;//将paraNode标记为1，表示该结点已经访问过 
	printf("%d\t",paraNode);
	for(i=0;i<paraGraphPtr->numNodes;i++){
		if(!visitedPtr[i]){//如果有未被访问的结点 
			if(paraGraphPtr->connection[paraNode][i]){//如果有paraNode的邻接点i(即[paraNode][i]为1) 
				DFS(paraGraphPtr,i);//递归调用DFS搜索邻接点i 
			}
		}
	}
}
/*广度优先搜索*/
void WFS(graphPtr paraGraphPtr, int paraStart/**/){
	//初始化辅助队列
	//printf("Begin to initialize queue.\r\n");
	QueuePtr tempQueue=initQueue();
	enqueue(tempQueue,paraStart);
	//printf("paraStart enqueued.\r\n");
	visitedPtr[paraStart]=1;
	printf("%d\t",paraStart);
	
	int i,j,tempNode;
	i=0;//i计数 
	while(!isQueueEmpty(tempQueue)){//队列不为空 
		tempNode=dequeue(tempQueue);//tempNode接收出队元素 
		//printf("tempNode=%d\r\n",tempNode);
		visitedPtr[tempNode]=1;//标记tempNode已经被访问 
		i++;//计数 
		for(j=0;j<paraGraphPtr->numNodes;j++){//遍历图寻找没有被访问且与tempNode有边的结点 
			if( visitedPtr[j]==0 && paraGraphPtr->connection[tempNode][j]==1){
				printf("%d\t",j);
				visitedPtr[j]=1;
				enqueue(tempQueue,j);
			}
		} 
		//printf("i=%d",i);
	}
	//printf("i=%d",i);
}
/*测试函数*/ 
void graphTranverseTest(){
	//初始化邻接矩阵	
	int myGraph[5][5] = { 
		{0, 1, 0, 1, 0},
		{1, 0, 1, 0, 1}, 
		{0, 1, 0, 1, 1}, 
		{1, 0, 1, 0, 0}, 
		{0, 1, 1, 0, 0}};
	printf("Preparing data\r\n");
	int i, j;
	int** tempPtr= (int**)malloc(5*sizeof(int*));
	for(i=0;i<5;i++){
		tempPtr[i]=(int*)malloc(5*sizeof(int));
		for(j=0;j<5;j++){
			tempPtr[i][j]=myGraph[i][j];
		}
	}
	printf("Data ready.\r\n");
	//初始化图
	graphPtr tempGraph=initGraph(5,tempPtr);
	printf("Graph initialized.\r\n");
	//DFS
	printf("DFS:\r\n");
	initVisitedPtr(tempGraph);//先将VisitedPtr数组初始化为0 
	DFS(tempGraph,4);
	//WFS
	printf("\r\nWFS:\r\n");
	initVisitedPtr(tempGraph);//将VisitedPtr数组初始化为0 
	WFS(tempGraph,4);
}
int main(){
	graphTranverseTest();
	return 0;
}

运行结果：

 使用邻接表的广度优先遍历算法：

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h> 
#define QUEUE_SIZE 10//队列空间大小 
int* visitedPtr;//记录结点是否已被访问 
typedef struct graphNodeQueue{
	int* node;
	int front;
	int rear; 
}graphNodeQueue,*QueuePtr;
/*初始化队列*/ 
QueuePtr initQueue(){
	QueuePtr resultPtr=(QueuePtr)malloc(sizeof(struct graphNodeQueue));
	resultPtr->node=(int*)malloc(QUEUE_SIZE*sizeof(int));
	resultPtr->front=0;
	resultPtr->rear=1;
	return resultPtr;
}
/*判断队列是否为空*/
bool isQueueEmpty(QueuePtr paraQueue){
	if((paraQueue->front+1)%QUEUE_SIZE==paraQueue->rear){
		return true;
	}
	return false;
}
/*结点入队*/
void enqueue(QueuePtr paraQueue,int paraNode){
	//判断队满
	if((paraQueue->rear+1)%QUEUE_SIZE==paraQueue->front%QUEUE_SIZE){//注意paraQueue->front也要%QUEUE_SIZE
		printf("Error,tring to enqueue %d,but queue full.\r\n");
		return;
	} 
	//让结点入队（入尾指针处） 
	paraQueue->node[paraQueue->rear]=paraNode;
	//更新队列尾指针 
	paraQueue->rear= (paraQueue->rear+1)%QUEUE_SIZE;
}
/*结点出队*/
int dequeue(QueuePtr paraQueue){
	//判断队空 
	if(isQueueEmpty(paraQueue)){
		printf("Error,empty queue.\r\n");
		return -1;
	}
	paraQueue->front=(paraQueue->front+1)%QUEUE_SIZE;
	//printf("dequeue %d ends.\r\n", paraQueue->node[paraQueue->front]);
	return paraQueue->node[paraQueue->front];
}
/*图的存储表示*/
typedef struct graph{
	int** connection;//邻接矩阵 
	int numNodes;//矩阵阶数 
}*graphPtr; 	
/*初始化图*/
graphPtr initGraph(int paraSize,int** paraData){
	int i,j;
	graphPtr resultPtr=(graphPtr)malloc(sizeof(struct graph));
	resultPtr->connection=(int**)malloc(paraSize*sizeof(int*));
	resultPtr->numNodes=paraSize; 
	for(i=0;i<paraSize;i++){
		resultPtr->connection[i]=(int*)malloc(paraSize*sizeof(int));
		for(j=0;j<paraSize;j++){
			resultPtr->connection[i][j]=paraData[i][j];
			//printf("i=%d,j=%d,connection[i][j]=%d.\r\n",i,j,resultPtr->connection[i][j]);
		}
	}
	return resultPtr;
}
/*图的存储结构*/
typedef struct AdjacencyNode{//邻接结点边表 
	int subscript;//邻接点域
	struct AdjacencyNode* next;//链域 
}AdjacencyNode,*AdjacentNodePtr;
typedef struct AdjacencyList{//邻接表顶点表 
	int numNodes;//结点数 
	struct AdjacencyNode* header;//一维数组
}AdjacencyList,*AdjacencyListPtr;
/*将图转换为邻接表*/
AdjacencyListPtr graphToAdjacentList(graphPtr paraGraph){
	//为邻接表分配空间 
	AdjacencyListPtr tempAdjList=(AdjacencyListPtr)malloc(sizeof(struct AdjacencyList));
	tempAdjList->numNodes=paraGraph->numNodes;
	tempAdjList->header=(AdjacentNodePtr)malloc(tempAdjList->numNodes*sizeof(struct AdjacencyNode));
	//创建邻接表
	int i,j;
	AdjacentNodePtr p, q;//p用于指示结点，q用于创建结点 
	for(i=0;i<paraGraph->numNodes;i++){
		//初始化边表 
		p=&(tempAdjList->header[i]);//p指向边表的头结点 
		p->subscript=-1;
		p->next=NULL;
		for(j=0;j<paraGraph->numNodes;j++){
			if(paraGraph->connection[i][j]==1){
				//创建新结点
				q=(AdjacentNodePtr)malloc(sizeof(struct AdjacencyNode));
				q->subscript=j;
				q->next=NULL;
				//链接
				p->next=q;
				p=q;//更新指针p,让它指向最后一个结点，便于下一次链接新结点 
			}//Of if 
		} //Of for
	} //Of for
	return tempAdjList;
}
/*打印邻接表*/
void printAdjList(AdjacencyListPtr paraAdjList){
	printf("The graph is:\r\n");
	int i;
	AdjacentNodePtr p; 
	for(i=0;i<paraAdjList->numNodes;i++){
		p=paraAdjList->header[i].next;
		while(p!=NULL){
			printf("%d\t",p->subscript);
			p=p->next;
		}//Of while
		printf("\r\n");
	}//Of for
} 
/*广度优先搜索邻接表*/
void WFS(AdjacencyListPtr paraAdjList,int paraStart){
	//初始化访问标志数组
	int i;
	visitedPtr=(int*)malloc(paraAdjList->numNodes*sizeof(int));
	for(i=0;i<paraAdjList->numNodes;i++){
		visitedPtr[i]=0;
	} 
	//队列
	QueuePtr tempQueue=initQueue();
	printf("%d\t",paraStart);
	visitedPtr[paraStart]=1;
	enqueue(tempQueue,paraStart);//让已访问的元素入队 
	int tempNode;//接收出队元素 
	AdjacentNodePtr p;//指向每一个边表的头结点 ，遍历边表
	while(!isQueueEmpty(tempQueue)){//队列不为空 
		tempNode=dequeue(tempQueue);//出队元素 
		for(p=&(paraAdjList->header[tempNode]);p!=NULL;p=p->next){
			if(visitedPtr[p->subscript]==0){
				printf("%d\t",p->subscript);
				visitedPtr[p->subscript]=1;
				enqueue(tempQueue,p->subscript); 
			}//Of if
		}//Of for
	}//Of while
} 
void WFSofAdjacencyListTest(){
	int i, j;
	int myGraph[5][5] = { 
		{0, 1, 0, 1, 0},
		{1, 0, 1, 0, 1}, 
		{0, 1, 0, 1, 1}, 
		{1, 0, 1, 0, 0}, 
		{0, 1, 1, 0, 0}};
	int** tempPtr;
	printf("Preparing data\r\n");
		
	tempPtr = (int**)malloc(5 * sizeof(int*));
	for (i = 0; i < 5; i ++) {
		tempPtr[i] = (int*)malloc(5 * sizeof(int));
		for (j = 0; j < 5; j ++) {
			tempPtr[i][j] = myGraph[i][j];
			//printf("i = %d, j = %d, %d\r\n", i, j, tempPtr[i][j]);
		}//Of for j
	}//Of for i
 
	printf("Data ready\r\n");
	
	graphPtr tempGraphPtr = initGraph(5, tempPtr);
	AdjacencyListPtr tempListPtr = graphToAdjacentList(tempGraphPtr);

	printAdjList(tempListPtr);
	printf("The WFS:\r\n");
	WFS(tempListPtr, 4);
}
int main(){
	WFSofAdjacencyListTest();
	return 0;
}

运行结果：  

 

西欢乐
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
图的存储与遍历（C语言实现）
01-08
包括两程序，一个是用邻接矩阵存储图实现深度优先遍历和广度优先遍历，一个是用临街链表存储实现深度优先遍历和广度优先遍历，均调试无误
C++实现图的邻接矩阵存储和广度、深度优先遍历实例分析
12-26
本文实例讲述了C++实现图的邻接矩阵存储和广度、深度优先遍历的方法。分享给大家供大家参考。具体如下： 示例：建立如图所示的无向图 由上图知，该图有5个顶点，分别为a,b,c,d,e,有6条边. 示例输入（按照这个格式输入）： 5 6 abcde 0 1 1 0 2 1 0 3 1 2 3 1 2 4 1 1 4 1 输入结束（此行不必输入） 注：0 1 1表示该图的第0个顶点和第1个定点有边相连，如上图中的a->b所示       0 2 1表示该图的第0个顶点和第2个定点有边相连，如上图中的a->c所示       2 3 1表示该图的第2个顶点和第3个定点有边相连，如上图中的c->d所示
【C 数据结构-图】3. 深度优先搜索、广度优先搜索
最新发布
普罗米修斯的博客
04-29 957
文章目录【 1. DFS 深度优先搜索 】1.1 基本原理1.2 C 实现【 2. BFS 广度优先搜索 】2.1 基本原理2.2 C 实现 对存储的图中的顶点进行遍历搜索，常用的遍历方式有两种：深度优先搜索和广度优先搜索。 【 1. DFS 深度优先搜索 】 1.1 基本原理 深度优先搜索的过程 类似于树的先序遍历，首先从例子中体会深度优先搜索。例如下图是一个无向图，采用深度优先算法遍历这个图的过程为： 首先任意找一个未被遍历过的顶点，例如从 V1 开始，由于 V1 率先访问过了，所以，需要标记
数据结构之图的表示、深度优先和广度优先遍历.zip
06-21
资源为数据结构之图形的两种存储形式的演示，包括邻接矩阵、邻接表，以及深度优先和广度优先遍历的两种实现，通过阅读可以提供对于图更加深刻的掌握
实现邻接矩阵存储图的深度优先遍历
02-09
C语言实现邻接矩阵存储图的深度优先遍历。
图的深度优先遍历和广度优先遍历
05-20
用邻接表存储表示图，完成了图的深度和广度优先遍历的操作。
数据结构实现—图的两种存储与两种遍历（CC++)
jdjhsj的博客
11-17 232
图最基本的算法，其他图论算法的基础
图的存储和遍历c语言,数据结构之C语言实现图的存储创建遍历
weixin_34518838的博客
05-17 424
零、编码前的准备1.构画草图：2.测试数据：邻接表的DFS与BFS测试数据：4 5ABCD0 10 20 31 23 2邻接矩阵的DFS与BFS测试数据：4 5ABCD0 1 50 2 100 3 101 2 153 2 30一、邻接矩阵包含四个文件的代码和一张测试效果图：AdjacencyMatrix.h文件： 构建邻接矩阵的存储结构与邻接矩阵的创建函数DBFSAdjacencyMatrix.h...
C语言 数据结构 图的储存、遍历、简单应用
kangyi158的博客
12-14 841
C语言 数据结构 图的储存、遍历、简单应用 内容： 1，创建图（邻接矩阵和邻接链表两种方法） 2，图的深度和广度优先搜索结果 3，判断图是否为连通图 #include<stdio.h> #include<stdlib.h> #include<string.h> #define MVNum 100 //最大顶点数 #define MAXSIZE 100 typedef char VerTexType; //设顶点的数据类型为字符型 typedef in
C语言——图的存储与遍历
MZYYZT的博客
03-11 2586
图的存储与遍历 内容 利用邻接矩阵描述示例图，编写程序输出示例图的深度优先搜索和广度优先搜索的遍历序列。 具体步骤如下： 将图的邻接矩阵描述为一个二维数组，并将该数组定义为全局变量，以便数据的传递； 定义一个队列，在广度优先搜索时，该队列存储已被访问的路径长度为1，2，…的顶点； 定义访问函数visit()、深度优先搜索函数DFS()和广度优先搜索函数BFS()； 主函数实现各函数的调用。 实验代码 下面展示一些 内联代码片。 #include <stdio.h> #define MAX
考研数据结构(十二):图的存储结构和图的遍历(C语言)
潘小蓝的博客
12-07 385
C语言实现图的邻接矩阵和邻接表存储结构,图的深度优先和广度优先遍历。
西电数据结构第七次上机 深度优先遍历
11-14
从键盘输入图的信息，包括顶点数、边数以及各条边。 1. 用邻接矩阵存储图，输出深度优先遍历的顶点序列； 2. 用邻接表存储图，输出深度优先遍历的顶点序列。
图的遍历 深度优先遍历 宽度优先遍历
07-04
[基本要求] 以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集。 [实现提示] 设图的结点不超过30个，每个结点用一个编号表示（如果一个图有n个结点，则它们的编号分别为1,2,…,n）。通过输入图的全部边输入一个图，每条边为一个数对，可以对边的输入顺序做出某种限制。注意，生成树的边是有向边，端点顺序不能颠倒。
树和二叉树的建立和遍历-数据结构试验报告.doc
08-27
本文档是关于树和二叉树的建立和遍历的实验报告，涵盖了树和二叉树的存储结构、遍历操作、Huffman 编解码算法等内容。 一、树和二叉树的存储结构 树和二叉树是数据结构中重要的概念。树是一种非线性数据结构，由...
数据结构--图的遍历及应用--思维导图.pdf
08-29
"数据结构--图的遍历及应用" 图的遍历是数据结构中的一种重要算法，指的是从图中某一顶点出发，按照某种搜索方法沿着图中的边对图中的所有顶点访问一次且仅访问一次。图的遍历可以分为两大类：广度优先遍历（BFS）...
数据结构（C语言版 第2版）课后习题答案 严蔚敏 编著
01-21
栈和队列是两种特殊的线性表，栈是一种后进先出的数据结构，队列是一种先进先出的数据结构。栈和队列的基本操作包括入栈、出栈、入队、出队等等。栈和队列的实现可以通过数组或链表来实现。 第四章 树和图 树是一...
哈工大数据结构实验三_图形结构及其应用
03-26
2．实现无向图的邻接矩阵和邻接表两种存储结构的相互转换算法； 3．在上述两种存储结构上，分别实现无向图的深度优先搜索（递归和非递归) 和广度优先搜索算法。并以适当的方式存储和显示相应的搜索结果（深度优先或 ...
C语言数据结构实验——图的遍历与应用
BeishangDeking的博客
02-11 270
实现kruskal算法，求解无向图的最小生成树。邻接矩阵实现图的深度优先遍历。邻接表实现图广度优先遍历。
图（深度优先遍历、广度优先遍历）
Ronz 的博客
01-27 5973
文章目录一、图的概述1.1 什么是图1.2 图对比线性表和树1.3 图的常见概念二、图的存储方式2.1 邻接矩阵2.2 邻接表三、图的遍历3.1 图的深度优先遍历3.1.1 什么是深度优先遍历3.1.2 深度优先遍历的步骤3.1.3 深度优先遍历代码实现3.2 图的广度优先遍历3.2.1 什么是广度优先遍历3.2.2 广度优先遍历的步骤3.2.3 广度优先遍历代码实现 一、图的概述 1.1 什么是图 图（graph）是一种数据结构，它是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G（V，E）。
数据结构实验建立有向图的邻接矩阵和邻接表存储结构，并实现两种遍历运算、简单路径求解：
06-02
接下来，让我们来实现两种遍历运算和简单路径求解： 1. 深度优先遍历（DFS）：从起点出发，尽可能深地探索每一个分支，直到该路径不能继续为止。然后回溯到前一个节点，继续探索其他分支。 2. 广度优先遍历（BFS）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值