C语言数据结构笔记(1)

最新推荐文章于 2022-11-27 18:34:41 发布
最新推荐文章于 2022-11-27 18:34:41 发布
阅读量723 收藏 3
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39863946/article/details/90320697
版权

第一章

1.1什么是数据结构

数据结构就是指计算机内部数据的组织形式和存储方法，主要包括：线性结构，树，图。
线性结构：由n个元素构成的有限序列。就是有限的一维数表。具体的讲线性结构包括：顺序表、链表、栈、队列等基本形式。顺序表和链表是从数据的储存形式上区分的，栈和队列是从逻辑功能上区分的。栈和队列是基于顺序表和链表的，他们由顺序表和链表构成。
树:“一对多”
图：“多对多”

1.2顺序表

顺序表的特征：
1.唯一的表名
2.内存单元连续储存
3.数据顺序存放

1.2.1定义顺序表

静态定义（与定义数组类似）

#define maxsize 100
Elemtype sqlist[Maxsize];//Elemtype顺序表的类型，可以是int char
int len;//定义顺序表的长度，方便对顺序表进行操作

动态定义

#define maxsize 100
typedef struct{
Elemtype *elem;
int length;
int listsize;
}sqlist;//定义类型为sqlist的结构体，其成员包括：顺序表的首地址，顺序表中表的长度，顺序表的储存空间容量；
void initsqlist(sqlist *L){//initsqlist（）的参数是sqlist类型的指针变量，因此可以直接在函数中对顺序表进行操作
L->elem=(int *)malloc(maxsize*sizeof(Elemtype));
if(!L->elem) exit(0);
L->length=0;//将L->length置为0，表明刚刚生成一张顺序表，此时表内尚无内容
L->listsize=maxsize;//将L->listsize置为maxsize，表明该顺序表占据的内存空间大小为maxsize（以sizeof（Elemtype）为单位）
}

结构体
link

函数malloc（）的用法：
link

1.2.2向顺序表中插入元素

基于静态顺序表

void Inserelem(Elemtype sqlist[],int &n,int i,Elemtype item){//向顺序表sqlist中第i个元素插入itme，该顺序表原长度为n
int t;
if(n==maxsize||i<1||i>n-1)
exit(0);//非法插入
for(t=n-1;t>=i-1;t--)
sqlist[t+1]=sqlist[t];//位置i-1与位置i-1以后的元素顺序向后移一位
sqlist[i-1]=item;//位置i-1插入item
n=n+1;//表长加1
}

基于动态顺序表

void Inserelem(sqlist *L,int i,Elemtype item){//向顺序表L中第i个位置上插入元素item
Elemtype *base,*insertptr,*p;
if(i<1||i>L->length+1)exit(0);//非法插入
if(L->length>=L->listsize)
{
	base=(Elemtype*)realloc(L->elem,(L->listsize+10)*sizeof(Elemtype));//重新追加空间
	L->elem=base;//更新内存基地址
	L->listsize=L->listsize+100;//储存空间增大100单元
}
//由于顺序表是建立在动态储存空间的，因此可以随时扩充，故向表尾插入元素时，如果顺序表已满，可以追加一段内存空间
insertptr=&(L->elem[i-1]);//insertptr为插入位置
for(p=&(L->elem[L->len-1]);p>=insertptr;p--)
{
*(p+1)=*p;//将i-1以后的元素顺序后移一个元素的位置
}
*insertptr=item;//在第i个位置上插入item
L->length++;表长加1
}

函数realloc（）的用法：
link

1.2.2从顺序表中删除元素

基于静态顺序表

void Delelem(Elemtype sqlist[],int &n,int i){//将顺序表sqlist中第i个元素删除，原顺序表的长度为n
int t;
if(i<1||i>n-1)
exit(0);//非法删除
for(t=i-1;t<=n-1;t++)
sqlist[t]=sqlist[t+1];//位置i-1与位置i-1以后的元素顺序向前移一位
sqlist[i-1]=item;
n--;//表长减1
}

基于动态顺序表

void Delelem(sqlist *L,int i){//向顺序表L中第i个位置上删除元素
Elemtype *p;
if(i<1||i>L->length+1)exit(0);//非法删除
for(p=&(L->elem[i-1]);p<=L->elem+L->length-1;p++)
{
*p=*(p+1);//将i-1以后的元素顺序后移一个元素的位置
}
L->length--;表长加1
}

1.3链表

在这里插入图片描述
链表的特征：
1.每个节点都有两部分：a.数据域：用来存放数据元素本身的信息、b.指针域：存放后继节点的位置。
2.链表在逻辑上连续，物理上不一定连续存储。
3.只要获得链表的头结点，就可以通过指针遍历整条链表。
C语言描述：

typedef struct node
{
	Elemtype data;//数据域
	struct node *next;//指针域
}LNode,*LinkList;

这种自定义的方式将struct node定义为LNode类型。这里*LinkList是指向LNode数据类型的指针型定义，也就是说：

LNode *L;

和

LinkList L;

是等价的。它们都定义了一个指向LNode类型的指针。

关键字typedef的用法：
link

1.3.1如何创建链表

尾插法创建链表

LinkList *Createlinklist(int n){//创建一条长度为n的链表
	int i;
	LinkList p,r,list=NULL;//p指向最后一个节点，r指向一般节点（当前生成的节点），list指向头结点
	for(i=0;i<n;i++){
		r=(LinkList)malloc(sizeof(Lnode));
		r->date=Get(n);//Get（）函数用来产生数据域的值
		r->next=NULL;
		if(list==NULL)//如果list为空，说明当前生成的节点是第一个节点，即头节点
			list=r;
		else 
			p->next=r;
			p=r;//将r的值赋给p，目的是让p再次指向最后一个节点，以便生成下一个节点，即保证p永远指向最后一个节点
	}
	return list;
}

头插法创建链表
link

1.3.2向链表中插入节点

在这里插入图片描述
在指针q指向的节点后面插入节点的步骤：
1.创建一个新节点用指针p指向该节点；
2.将q指向节点的next域内容赋值给p指向节点的next域；
3.将p的值赋给q的next域。
代码描述如下：

void insertList(LinkList *list,LinkList q,ElemType e){
	LinkList p;
	p=(LinkList)malloc(sizeof(LNode));//生成一个新节点，由p指向它
	p->date=e;//新节点的数据域赋值e
	p->next=NULL;
	if(*list==NULL){//当链表为空时
		*list=p;
	}
	else 
	{
		p->next=q->next;//将q指向的节点的指针域赋给p指向节点的指针域
		q->next=p;//将p赋值给q指向节点的指针域
	}
}

caution
函数insertList（）的参数中有一个LinkList *list，他是指向LinkList类型的指针变量，相当于指向LNode类型的指针的指针。这是因为在函数中要对list，也就是表头指针进行修改，而调用该函数时，实参时&list，而不是list。因此必须采用指针参数传递的办法，否则无法在被调函数中修改主函数中定义的变量的内容。

1.3.3从链表中删除结点

1.q所指向的是链表的第一个节点。只需将q所指结点的指针域next的值赋值给头指针list，让list指向第二个节点，在释放掉q所指结点即可。
在这里插入图片描述

2.当q所指向的前驱结点的指针已知时（假设为r），只需将q所指结点的指针域next的值赋给r的指针域next，再释放掉q所指结点即可。在这里插入图片描述
3.当q所指向的前驱结点的指针未知。
代码描述如下：

void deLink(LinkList *list,LinkList r,LinkList q)
{
	if(q==*list)
		*list=q->next;//删除链表的第一种情形
	else
		r->next=q->next;//删除链表的第二种情形
	free(q);
}

当q所指向的结点的前驱结点未知时，需要先通过链表头指针list遍历链表，找到q的前驱结点的指针，将该指针赋值给指针变量r，再按照第二种情形去做即可。
代码描述如下:

void deLink(LinkList *list,LinkList q){
	LinkList r;
	if(*list==q){
		*list=q->next;
		free(q);
	}
	else{
		for(r=*list;r->next==q;r=r->next);//遍历链表，找到q的前驱结点的指针
		r->next=q->next;
		free(q);
	}
}

1.3.4销毁一个链表

从首节点开始销毁:

void destroyLinkList(LinkList *list){
	LinkList q,p;//p指向当前要销毁的结点，q用来保存每次销毁后的链表。
	p=*list;
	while(p){//判断只要p不为空（NULL），就将p指向下个结点的指针赋给q，并应用函数free（）释放掉p所指向的结点，p再指向下一个结点。
		q=p->next;
		free(p);
		p=q;
	}
	*list=NULL;//防止list变为野指针。链表再内存也被完全的释放掉了
}

free()的用法
link

1.4 栈

栈就是一个线性表，具有以下特点：
1.先进后出；
2.栈的操作只能在栈顶也就是表尾进行。
在这里插入图片描述
顺序栈的代码表述：

typedef struct {
	Elemtype *base;//指向栈底，Elemtype 是栈内储存的数据类型，可以是int char 等
	Elemtype *top;//指向栈顶，对栈进行操作
	int stacksize;//栈的容量
} sqStack;

1.4.1 栈的初始化

#define STACK_SIZE 100
void Initstack(sqStack *s)
{
	s->base=(sqStack *)malloc(STACK_SIZE*sizeof(sqStack));//为栈分配STACK_SIZE大小的空间
	if(s->base==NULL)exit(0);//分配失败
	s->top=s->base;//刚创建时由于是空栈，所以栈顶就是栈底
	s->stacksize=STACK_SIZE ;
}

初始化后栈的示意图如下：
在这里插入图片描述

1.4.2 入栈操作

void push(sqStack *s,elem e)
{
	if(s->top-s->base==s->stacksize){//判断是否栈满，若栈满，则追加空间
		s->base=(sqStack *)realloc(s->base,(s->stacksize+10)*sizeof(sqStack));
		if(s->base==NULL) exit(0);
		s->top=s->base+s->stacksize;//s->top指针移动到s->base+s->stacksize的位置上
		s->stacksize=s->stacksize+10;//栈容量更新；
	}
	*(s->top)=e;
	s->top++;//top始终指向栈顶元素的上一个空间；
}

1.4.3 出栈操作

void pop(sqStack *s,elemtype *e)
{
	if(s->top==s->base) exit(0);//若为空栈则返回
	else{//top指针下移，然后将其所指的内容取出
	s->top--;
	*e=*s->top;
	}
}

1.4.3 其他操作

清空：

void Clearstack(sqStack *s)
{
	s->top=s->base;
}

tip：清空一个栈只是清空了栈的内容，但是栈的物理空间并未销毁
销毁：

void Destroystack(sqStack *s)
{
	int i,len;
	len=s->stacksize;
	for(i=0;i<len;i++)
	{
		free(s->base);
		s->base++;
	}
	s->top=s->base=NULL;
	s->stacksize=0;
}

计算容量

int Stacklen(sqStack *s)
{
	return(s.top-s.base);
}

1.5 队列

1.一种先进先出的线性表；
2.只允许数据在队列的队尾进入，在队列的队头取出。
只要掌握了队列的队头指针和队尾指针就可以对队列进行各种操作。
在这里插入图片描述
基于链表的队列称为链队列，代码表述如下：

typedef struct QNode{
	Elemtype date;
	Qnode *next;
}QNode,*Queueptr;
typedef struct{
Queueptr front;//指向链表的头部
Queueptr rear;//指向链表的尾部
}LinkQueue;

1.5.1 初始化一个队列

有两个任务：
1.创建一个头结点；
2.将队列的头指针和尾指针都指向这个结点。
代码表述如下：

void InitQueue(LinkQueue *s)
{
	s->rear=s->front=(QNode *)malloc(sizeof(Qnode));
	if(s->front==NULL)exit(0);
	s->front->next=NULL;//将头结点的指针域置空
}

在这里插入图片描述

1.5.2 入队列操作

void InsertQueue(LinkQueue *s,Elemtype e)
{
	Queueptr p;
	p=(Queueptr)malloc(sizeof(QNode));//创建一个指向新节点的Queueptr型指针
	if(s->head==NULL) exit(0);
	p->next=NULL;
	p->date=e;//将数据加入到链表新节点的数据域
	s->rear->next=p;//向链表的尾部添加新结点
	s->rear=p;//队尾指针指向新节点
}

过程如下图所示：
在这里插入图片描述

1.5.3 出队列操作

每当有数据从队列种移出时，队头结点不会改变，但是队头结点的next指针会后移，当队列中只有一个元素时，取出数据后，队尾指针也将移到队头。代码描述如下：

void DeQueue(LinkQueue *s,Elemtype *e)//将队列s的头元素取出，将结果存入e
{
	Queueptr p=NULL;
	if(s->front==s->rear) exit(0);
	p=s->front->next;
	*e=p->date;
	s->front->=p->next;
	if(p==s->rear) s->rear=s->front;//若队列种只有一个元素，则取出这个元素后队列将变成空队列，于是将队尾指针移动到队头
}

在这里插入图片描述
在这里插入图片描述

1.5.4 销毁队列操作

void DestroyQueue(LinkQueue *s)
{
	while(s->front){
		s->rear=s->front->next;
		free(s->front);
		s->front=s->rear;
	}
}

1.5.5 循环队列

循环队列实际上是一个线性表，具有固定的储存空间。
与一般的队列相同的是：元素必须从队尾入队列，必须从队头出队列；
与一般队列不同的是：循环队列的头指针和尾指针随着队列元素的出入不断地发生变化（一般队列是头指针不发生变化，头指针的next指针和尾指针前一个元素的next指针发生变化）
循环队列的逻辑结构如下：

这里约定：循环队列的队头指针始终指向第一个元素，队尾指针始终指向最后一个元素的下一个空间，逻辑上就是一个首尾连接的环形缓冲区

1.5.6 循环队列的实现

逻辑上用取模的运算结果，无论是入队列的front+1操作还是出队列的rear+1操作，实际上都是模加操作，这样才能在连续的线性空间中模拟出逻辑上循环的队列；代码描述入下：

  1. 定义一个循环队列
#define maxsize 100
typedef struct{
	Elemtype *base;
	int front;
	int rear;
}cycleQueeue;
  1. 初始化一个循环队列
void Initqueue(cycleQueeue *s)
{
	s->base=(Elemtype *)malloc(maxsize*sizeof(Elemtype ));
	if(q->base==NULL)exit(0);
	s->front=s->rear=0;
}
  1. 向循环队列中加元素
void Insertqueue(cycleQueeue *s,Elemtype e)
{
	if((s->rear+1)%maxsize==s->front)exit(0);
	s->base[s->rear]=e;
	s->rear=(s->rear+1)%maxsize;
}
  1. 向循环队列中删除元素
void Deletqueue(cycleQueeue *s,Elemtype *e)
{
	if(s->front==s->rear) return;
	*e=s->base[s->front];
	s->front=(s->front+1)%maxsize;
}

1.6 树结构

树结构采用的是非线性结构组织数据
树的定义：树由n个结点组成的有穷集合，在任意一颗非空树中：
1.有且仅有一个根节点；
2.当n>1时，其余结点分为m（m>0）个有限集，其中每个集合本身又是一棵树，称为根的子树。
在这里插入图片描述

1.6.1 树结构的计算机储存形式

树在计算机中用多重链表储存，代码表述如下：

typedef struct  node{
	datetype date;//结点的数据域，用来储存数据；
	struct node *childnode[10];//结点的指针域，为一个指针数组，数组里的每一个指针都指向孩子结点
}

在这里插入图片描述

1.6.2 二叉树的定义

二叉树是这样的树结构：它或者为空，或者由根结点加上互不交叉的称为左子树和右子树的二叉树组成，链式储存的二叉树结点的储存结构如下：
在这里插入图片描述
代码表述如下：

typedef struct BiTNode
{
	dateType date;//结点的数据域；
	struct BiTNode *rchild,*lchild;//指向左孩子和右孩子
}BiTNode,*bitree;

其中：

BiTNode *t;

等价于

bitree t;

1.6.3 二叉树的遍历

  1. 先序遍历：1.访问根节点 2.先序遍历左子树 3.先序遍历右子树
void Preordertraverse(bitree T)
{
	if(T)//递归结束条件，T为空
	{
		visit(T);//访问根节点
		Preordertraverse(T->lchild);//先序遍历左子树
		Preordertraverse(T->rchild);//先序遍历右子树
	}
}
  1. 中序遍历：1.中序遍历左子树 2.访问根节点 3.中序遍历右子树
void Inordertraverse(bitree T)
{
	if(T)//递归结束条件，T为空
	{
		Inordertraverse(T->lchild);//中序遍历左子树
		visit(T);//访问根节点
		Inordertraverse(T->rchild);//中序遍历右子树
	}
}
  1. 后序遍历：1.后序遍历左子树 2.后序遍历右子树 3.访问根节点
void Posordertraverse(bitree T)
{
	if(T)//递归结束条件，T为空
	{
		Posordertraverse(T->lchild);//后序遍历左子树
		Posordertraverse(T->rchild);//后序遍历右子树
		visit(T);//访问根节点
	}
}

这里面visit()函数的作用要具体而定；

1.6.4 创建二叉树

用先序遍历创建一棵二叉树，代码描述如下：

typedef struct BiTNode
{
	char date;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void CreatBitree(BiTree *t)
{
	char e;
	scanf("%c",&e);
	if(e==' ')*t=NULL;
	else
	{
		*t=(BiTree)malloc(sizeof(BiTNode));
		*t->date=e;
		CreatBitree(&(*t->lchild));
		CreatBitree(&(*t->rchild));
	}
}

在这里插入图片描述
若创建上面的二叉树，则需要输入的内容为:ABC@@D@@E@F@@。

1.7 图结构

图是由非空有限集合V（由N个顶点构成）和边的集合E构成（顶点之间的关系），若图G的每一条边都没有方向，则称为无向图，若图G的每一条边都有方向，则称为有向图。
在这里插入图片描述

1.7.1 邻接表的定义

图的邻接表储存方式是顺序数组和链表相结合的储存方式：顺序数组用来储存顶点信息，链表用来储存边的信息，对图中的每一个顶点建立一个链表，每个链表前面设置一个结点称为顶点结点。顶点结点的结构如下：
在这里插入图片描述
vertex域存放顶点的数据信息，next域存放连接顶点的第一条边。边结点的结构如下：

adjvex域用来存放该边的另一顶点在数组中的位置（数组下标）；weight用来存放该边的权重，对于无权重的图，该项省略；next将第i个链表的所有边结点连接成一个链表，最后一个边结点的next域指向NULL。
在这里插入图片描述
无向图的邻接表储存形式如下：
在这里插入图片描述
代码描述如下：

#define maxvertex 20
typedef struct arcnode//定义边结点
{
	int adjvex;//边在图中的位置；
	struct arcnode *next ;//指向下一条边
	infotype *weight;//边的权重，可省略
}arcnode;
typedef struct vnode//定义顶点结点
{
	elemtype date;//顶点中存放的数据
	arcnode *firstarc;//指向连接顶点的第一条边
}vnode;
vnode G[maxvertex ];//定义vnode类型的数组G，它是储存图的容器

1.7.2 图的创建

应先画出图的逻辑结构，以下图为例：
在这里插入图片描述
上图的邻接表储存形式为：

在这里插入图片描述
创建一个图的步骤为：
（1）：创建顶点结点：即创建储存表中顶点的顺序表；
（2）：创建边结点：即创建储存表中的单链表；
代码描述如下:

CreatGraph(int n,vnode G[])
{
	arcnode *p,*q;
	int i,e;
	for(i=0;i<n;i++)
	{	
		G[i].date=Getdate();
		G[i].firstarc=NULL;
	}
	for(i=0;i<n;i++)
	{
		printf("Creat the edges for the %dth vertex:\n",i);
		scanf("%d",&e);
		while(e!=-1)
		{
			p=(arcnode *)malloc(sizeof(arcnode));
			p->adjvex=e;
			p->next=NULL;
			if(G[i].firstarc=NULL)G[i].firstarc=p;
			q->next=p;
			q=p;
			scanf("%d",&e);
		}
	}
}

1.7.3 图的遍历（1）——深度优先搜索

void DFS(vnode G[],int v)
{
	int w;//w为标志位
	visit(v);//访问v结点
	visit[v]=1;//将数组visit[]v结点对应的位置1，表示该节点已经被访问
	w=FirstAdj(G,v);//查询v结点的第一个邻接点，w中返回的是第一个邻接点在图中的位置，若v无临界点则返回-1
	while(w!=-1)
	{
		if(visit[w]==0)
		DFS(G[],w);//若visit[w]为0表示w结点未被访问过，否则递归访问其他结点
		w=NextAdj(v);//查询v结点的下一个邻接点，若没有下一个邻接点，则返回-1
	}
}

void Travel_DFS(vnode G[],int visit[];int n)
{
	int i;
	for(i=0;i<n;i++)
	visit[i]=0;//visit[]中记录的是第i个结点有没有被访问的情况，刚开始的时候visit[]中的元素全置0，表示所有的结点都未被访问过
	for(i=0;i<n;i++)
	if(visit[v]==0)
	DFS(G[],i);//若第i个结点对应的元素为0，则递归访问i个结点
}

在这里插入图片描述
用上述递归遍历图1-37非连通图的过程如下：
假设以v0为遍历的起点，访问标志数组初始值为visit[5]={0,0,0,0,0}
1.访问v0结点，将数组visit[]中v0结点对应的位置置1；
2.查询v0结点的第一个邻接点v1，w=1；
3.数组visit[]中v10成立，因为它没有被访问过；接下来执行函数DFS(G[],1)，即递归查询；
3.1访问v1结点，将数组visit[]中v1结点对应的位置置1；
3.2查询v1结点的第一个邻接点v2，w=2；
3.3数组visit[]中v20成立，因为它没有被访问过；接下来执行函数DFS(G[],2)，即递归查询；
3.3.1访问v2结点，将数组中v2结点对应的位置置1；
3.3.2查询v2结点的第一个邻接点v0,w=0；
3.3.3数组visit[]中v0==0不成立，因为它已经被访问过；
3.3.4查询v2结点的下一个邻接点，w=-1；因为都被访问过；
3.4查询v1结点的下一个邻接点，w=-1；因为都被访问过；
4.查询v0结点的下一个邻接点，w=-1，因为都被访问过；
DFS()结束。

1.7.4 图的遍历（2）——广度优先搜索

void BFS(VNode G[],int v)
{
	int w;
	visit(v);//访问结点v
	visited[v]=1;//结点v对应的数组位置置1
	EnQueue(q,v);//结点v入队列
	while(EmptyQ(q))//只要队列不为空，则进行以下的操作
	{
		DeQueue(&q,&v);//出队列，元素由v返回
		w=FirstAdj(G,v);//搜索v的第一个邻接点，若没有邻接点则返回-1
		while(W!=-1)
		{
			if(visited[w]==0)
			{
				visit(w);
				EnQueue(&q,&w);//若visited[w]==0,说明结点w未被访问过，则执行访问结点w，并将结点w入队列
			}
			visited[w]=1;//访问结点w后将visited[]数组w对应位置1
			w=NextAdj(G,v);
		}
	}
}

void Travel_BFS(VNode G[],int visited[], int n)//主函数
{
	int i;
	for(i=0;i<n;i++)
	{
		visited[i]=0;
	}
	for(i=0;i<n;i++)
	if(visited==0)
	BFS(G[],i);
}

在这里插入图片描述
遍历的步骤如下：
1.访问结点v0,结点v0入队列，此时队列为{v0}，将顶点v0对应的访问标记置1，此时visited[]数组为{1，0，0，0，0}；
2.结点v0出队列，元素由v返回，找到v0的第一个邻接点v1，访问v1，v1入队列，此时队列为{v1}，将顶点v0对应的访问标记置1，此时visited[]数组为{1，1，0，0，0}；找到v0的下一个邻接点v2；
3.访问v2,v2入队列，此时队列为{v1,v2}，将顶点v2对应的访问标记置1，此时visited[]数组为{1，1，1，0，0}；下一次执行NextAdj（）时，将返回-1；
4.结点v1出队列，此时队列为{v2}，找到v1的第一个邻接点v3，访问v3，v3入队列，此时队列为{v2，v3}，将顶点v3对应的访问标记置1，此时visited[]数组为{1，1，1，1，0}；找到v1的下一个邻接点v4；
5.访问v4,v4入队列，此时队列为{v2，v3，v4}，将顶点v4对应的访问标记置1，此时visited[]数组为{1，1，1，1，1}；下一次执行NextAdj（）时，将返回-1；
6.结点v2出队列，此时队列为{v3，v4}，由于v2没有邻接点，执行FirstAdj时将返回-1；
7.结点v3出队列，此时队列为{v4}，由于v3没有邻接点，执行FirstAdj时将返回-1；
8.结点v4出队列，此时队列为空，由于v4没有邻接点，执行FirstAdj时将返回-1
BFS结束；
其中FirstAdj（）函数的代码表述如下：（该函数的功能是返回顶点v的第一个邻接点在数组G中的下标。如果该顶点无邻接点，则返回-1）

int FirstAdj(VNode G[],int v)
{
	if(G[v].firstarc->NULL) return -1;
	else return (G[v].firstarc)->adjvex;
}

NextAdj（）函数的代码表述如下：

int NextAdj(VNode G[],int v)
{
	arcnode *p;
	p=G[v].firstarc;
	while(p!=NULL)
	{
		if(visited[p->adjvex]) p=p->next;//该顶点已被访问，继续向下查找
		else return p->adjvex;//返回v的下一个邻接点在数组G中的下标
	}
	return -1;//已经没有下一个邻接点
}
ＱＱ音乐
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
常见的数据结构面试题
cabbage_mm的专栏
05-09 2万+
常见的数据结构面试题，看看你能做出几题来2007年01月11日 星期四 14:15 1.       在一个单链表中p所指结点之前插入一个s (值为e)所指结点时，可执行如下操作：q=head;while (q->next!=p)  q=q->next;s= new  Node;   s->data=e;
数据结构图之邻接点
热门推荐
菜菜鸟的成长记录
12-06 1万+
图的邻接表表示法是一种链式的存储方式,为图中的每一个顶点建立单链表用来表示边或者弧, 这种用来表示点点之间关系的表成为边表或者弧表,相应的结点称为边结点,可以在每一个单链表前面设置头结点用于存放图中的顶点结点, 这种表被称为表头结点表,相应的结点被称为表头结点,通常情况下,表头结点采用顺序存储结构方式存储,这样方便随机访问结点, 表头结点由2个域组成的,一个数据域一个指针域,数据域用于存放顶
（数据结构&C语言）对链表的认识
最新发布
XY_Mckevince的博客
11-27 434
线性表的链式存储结构-单链表
数据结构-06 图
simple_a的博客
03-20 369
创建临界矩阵来表示图 //表示不相连 int MAX_WEIGHT = 1000; //构建用来表示图的邻接矩阵 int[][] matrix = {{0,10,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT,11,MAX_WEIGHT,MAX_WEIGHT,MAX_WEIGHT}, {10,0,18,MAX_WEIGHT,MAX_
【邻接表】69 邻接表：构造有权图
windyuan~
03-02 1984
问题描述 : 目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。 内容： （1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。） （2）使用构造函数，构造一个有权图。 注意：DG（有向图）, DN（有向网）, UDG（无向图）, UDN（无向网） 参考函数原型： //构造函数构造一个有权图。6个参数的含义：图的类型..
6-5图-图的基本操作
欢迎来到我的博客
04-26 504
图的基本操作函数及复杂度分析
C语言数据结构学习笔记及例题
10-29
数据结构学习笔记及例题
耶鲁大学C语言和数据结构笔记
06-24
"耶鲁大学C语言和数据结构笔记" 本资源主要介绍了耶鲁大学CPSC 223课程的笔记，涵盖了C语言和数据结构的基础知识。课程讲述了基本的编程技术和数据结构，旨在帮助学生学习C语言和数据结构的基础知识。 数据结构 ...
c语言数据结构学习笔记.pdf
08-17
适合已经入门c语言、学习编程中数据结构的人员
王道数据结构+C语言版+超全笔记(图文)+个人整理版本
04-05
(一)数据元素、数据结构、抽象数据类型等概念 (二)算法设计的基本要求 (三)语句的频度和估算时间复杂度 二、线性表 (一)线性表的定义和基本操作 (二)线性表的实现 1.顺序存储结构 2.链式存储结构 3.线性表的应用 三...
C语言线性数据结构
weixin_44230855的博客
07-24 395
C语言线性数据结构 最近在学习数据结构 写博客记录一下，很久没写过c语言了，也是现学现用。 线性表的顺序存储结构 *顺序表的三个属性： 1.存储空间的起始位置（数组名data） 2.顺序表最大存储容量（MaxSize） 3.顺序表当前的长度（length） 编译器为vc6 // 头文件 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include "windows.h" #define M
c语言里的线性结构,考研笔记数据结构线性结构之C语言
weixin_39593460的博客
05-22 170
一千个教程又一千种说法。数据结构的教材上都是伪代码。那么我认为写汉语也行咯。干脆全部用标准代码敲下来。到时候背一下。专业课其实就是在考背诵。手头没有编译器希望大家能够提出意见。约定Code:#defineTRUE1#defineFALSE0#defineERROR0#defineINFEASIBLE-1#defineOVERFLOW-2#defineOK1线性表静态线性表书...
c语言编程之队列(链表实现)
weixin_34159110的博客
08-18 112
用链表实现了队列，完成了队列的入队和出队功能。 1 #include"stdio.h" 2 3 typedef int element; 4 5 typedef struct Node{ 6 struct Node *next; 7 element data; 8 }*pNode; 9 ...
OJ 邻接表的相关操作
Eli_Code
05-31 2967
邻接表的相关操作 时间限制: 1 Sec 内存限制: 128 MB 题目描述： 输入一个图，用邻接表存储，并实现一些操作。 拷贝下面的代码，按要求完成其中的FirstAdjVex，NextAdjVex，sort和CreateUDG操作，其他地方不得改动。 //图的邻接表存储表示 #include <iostream> #include <iomanip> using namespace std; #define MVNum 100 //最大顶点数 #defi
嵌入式、c/c++试题
Charlson_S的博客
09-21 9477
第一份 参考链接: 面试积累. 1. 用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题） #define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL 注意点： 1). #define 标识符 字符串 --基本知识 凡是以“#”开头的均为预处理命令。“define”为宏定义命令。“标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等 宏定义不是说明或语句，在行末不必加分号，如加上分号则连分号也一起置换。 宏定义必须写在函数之外
数据结构题目整理（编程）
paintShadow的博客
09-15 8774
0-1求链式表的表长 本题要求实现一个函数，求链式表的表长。 函数接口定义： int Length( List L ); 其中List结构定义如下： typedef struct LNode *PtrToLNode; struct LNode { ElementType Data; PtrToLNode Next; }; typedef PtrToLNode List; L是给...
线性表：顺序表和链表的定义，接口实现，功能讲解，二者区别，分别适用于什么场景。
qq_39487033的博客
08-20 2699
线性表 顺序表的定义 顺序表，我把它简单的理解为一个结构体里，存了两个成员，一个数组data（为了保存数据），一个整型sz（记录数组中数据的个数）。因为顺序表有连续排列的顺序，所以用数组保存数据更方便。定义代码如下： typedef int DATA_TYPE; typedef struct PSeqList { DATA_TYPE data[MAX]; int sz...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值