图的链式存储结构的建立

最新推荐文章于 2024-01-04 22:06:27 发布
原创 最新推荐文章于 2024-01-04 22:06:27 发布 · 1k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 

<pre name="code" class="cpp">#ifndef Graph_H
#define MAX_VEX_NUM 20 
#define OK 1
#define MAX_NAME 3/*顶点字符串的最大长度+1*/
#define MAX_INFO 20/*相关字符串的最大长达+1*/
/////////////结构定义//////////////////////////
//图的种类有向图，有向网，无向图，无向网
typedef enum{DG,DN,AG,AN} GraphKind ;
typedef int InfoType ;
typedef char VertexType[MAX_NAME];
typedef int Status ;
typedef int VRType;  

typedef struct ArcNode{
	int adjvex;               //该弧指向的顶点的位置
	struct ArcNode *nextarc; //指向下一条弧的指针
	InfoType *info ;         //网的权值指针
}ArcNode;    /*表结点*/

typedef struct{
	VertexType data ;        //顶点信息
	ArcNode *firstarc;       //指向第一条弧
}VNode,AdjList[MAX_VEX_NUM];

typedef struct{
	AdjList vertices; //顶点的数组
	int vexnum,arcnum ;//图当前顶点的个数和弧数
	int kind ; //图的种类
}ALGraph; 
////////////////////////////////////////////////
//////////////最小生成树////////////////////////
/*辅助结构*/
typedef struct Minimum{ //此结构存放当前过程中V中各节点到U中各节点的最小权值信息  
    VertexType data;    //保存U中与V中该结点相连接的结点值，使V中该结点到U中各节点间权值最小  
    VRType lowcost;     //保存两结点间最小的权值(代价)  
    int flag;           //表示V中该结点在某一过程中是否被更新的标志，flag=0表示尚未更新，flag=1表示已经更新，不用再更新了，图使用邻接表存储时要注意设置此标志，以免某一结点的minimum结构被更新多次，得不到正确的最小权值  
}Minimum,closedge[20];  
//////////////////////////////////////////////////////
////////////////////////操作定义///////////////
int LocateVex(ALGraph G,VertexType u);
Status CreateGraph(ALGraph *G);
void Destory(ALGraph *G);
VertexType* GetVex(ALGraph G ,int v);
Status PutVex(ALGraph *G, VertexType v,VertexType value);
int FirstAdjVex(ALGraph G,VertexType v);
int NextAdjVex(ALGraph G,VertexType v,VertexType w);
void InsertVex(ALGraph *G, VertexType v);
Status DeleteVex(ALGraph *G, VertexType v);
Status InserArc(ALGraph *G, VertexType v,VertexType w);
Status DeleteArc(ALGraph *G,VertexType v,VertexType w);

void DFS(ALGraph G,int v);
void DFSTraverse(ALGraph G);
void BFSTraverse(ALGraph G);
void Display(ALGraph G);
void Visit(char s[]);

int minimum(ALGraph G,closedge MinEdge);
void MinSpanTree(ALGraph G,VertexType u);
//////////////////////////////////////////////

//////////////////////队列////////////////////
#define ERROR 0
#define OVERFLOW -2 

typedef int QElemType;
typedef int Status;

typedef struct QNode{
	QElemType data ;
	struct QNode *next ;
}QNode , *QueuePtr;

typedef struct {
	QueuePtr front ;
	QueuePtr rear ;
}LinkQueue;

//--------基本操作------------
Status InitQueue(LinkQueue &Q);
Status DestroyQueue(LinkQueue &Q);
Status ClearQueue(LinkQueue &Q);
Status QueueEmpty(LinkQueue Q);
int QueueLength(LinkQueue Q);
Status GetHead(LinkQueue Q,QElemType &e);
Status EnQueue(LinkQueue &Q,QElemType e);
Status DeQueue(LinkQueue &Q,QElemType &e);
bool IsEmpty(LinkQueue Q);
//////////////////////////////////////////////
#endif
 

</pre><p></p><p><pre name="code" class="cpp">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Graph.h"




//////////////////操作的具体实现//////////////////


int LocateVex(ALGraph G,VertexType u){
	/*初始条件:图G存在，u和G中的顶点有相同的特征*/
	/*操作结果: 若u在G中，则返回u顶点的位置，否则返回-1*/
	int i ;
	for(i=0;i<G.arcnum;i++)
		if(strcmp(u,G.vertices[i].data)==0)
			return i ;
		return -1 ;
	
}

Status CreateGraph(ALGraph *G){
	/*采用邻接表存储结构,构造没哟u相关信息的图G(用一个函数构造4中图)*/
	int i,j,k;
	int w ;   /*权重*/
	VertexType va,vb ;
	ArcNode *p;
	printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
	scanf("%d",&((*G).kind));
	printf("%d",G->kind);
	printf("请输入图的顶点数,边数: ");
	scanf("%d,%d",&((*G).vexnum),&((*G).arcnum));
	printf("请输入%d个顶点的值(<%d个字符): \n",G->vexnum,MAX_NAME);
	/*构造顶点向量*/
	for(i=0;i<G->vexnum;i++){
		scanf("%s",&(*G).vertices[i].data);
		(*G).vertices[i].firstarc=NULL ;

	}
	
	if(G->kind==1||G->kind==3)/*网*/
		printf("请输入每条弧(边)的权值，弧尾和弧头(以空格作为间隔): \n");
	else  /*图*/
		printf("请顺序输入每条弧的弧尾和弧头(以空格作为间隔): \n");
	for(k=0;k<G->arcnum;k++){
		if(G->kind==1||G->kind==3)
			scanf("%d%s%s",&w,va,vb);
		else
			scanf("%s%s",va,vb);
		i=LocateVex(*G,va); /*弧尾*/

		j=LocateVex(*G,vb); /*弧头*/

		p=(ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex=j;
		if(G->kind==1||G->kind==3){//网
			p->info= (int *)malloc(sizeof(int));
			*(p->info)=w;
		}else{
			p->info=NULL;
		}
		p->nextarc = G->vertices[i].firstarc;/*插在表头*/
		G->vertices[i].firstarc = p;

		if(G->kind>=2){/*无向图，或网产生第二个结点*/
			p=(ArcNode*)malloc(sizeof(ArcNode));
			p->adjvex=i;
			if(G->kind==3){
				p->info=(int *)malloc(sizeof(int));
				*(p->info)=w;
			}else
				p->info=NULL;
			p->nextarc = G->vertices[j].firstarc;
			G->vertices[j].firstarc=p;
		}

	}
	return OK ;
}

void Destory(ALGraph *G){
	/*初始条件:图G存在,操作结果:销毁G*/
	int i ;
	ArcNode *p,*q;
	for(i=0;i<G->vexnum;i++){
		p=G->vertices[i].firstarc;
		while(p){
			q=p->nextarc;
			if(G->kind%2){/*网,这与前面的规定顺序有关*/
				free(p->info);
			}
			free(p);
			p=q;
		}
	}
	G->arcnum = 0;
	G->vexnum = 0;
}
VertexType* GetVex(ALGraph G,int v){
	/*初始条件:图G存在,v是图中某个顶点的序号.*/
	/*操作结果:返回序号为v顶点的值*/
	//1.判断位置,体现程序的健壮性
	if(v>G.vexnum||v<0){
		printf("位置不正确\n");
		exit(-1);
	}
	return &G.vertices[v].data;
}

Status PutVex(ALGraph *G, VertexType v,VertexType value){
	/*初始条件:图G存在，v为图中顶点，value为替换v的值*/
	/*操作结果:将图G中的v替换成新的值value*/
	int i ;
	i= LocateVex(*G,v);
	if(i<0){
		printf("图G中不存在值为%d的顶点\n",v);
		return -1;
	}

	strcpy(G->vertices[i].data , value) ;
	return OK ;
}

int FirstAdjVex(ALGraph G,VertexType v){
	/*初始条件:图G存在，v为图G中的某个顶点*/
	/*操作结果:返回v的第一个邻接顶点的序号,若不存在则返回-1*/
	ArcNode *p;
	int v1 ;//顶点v在图G中的序号
	v1= LocateVex(G,v);
	p=G.vertices[v1].firstarc;
	if(p)
		return p->adjvex;
	return -1 ;

}

int NextAdjVex(ALGraph G,VertexType v,VertexType w){
	/*初始条件:图G存在,v是G中的某个顶点,w是v的邻接顶点*/
	/*操作结果:返回v(相对于w)的下一个邻接顶点的序号，若w是最后一个节点，返回-1*/
	ArcNode *p;
	int v1,w1 ;
	v1 = LocateVex(G,v);
	w1 = LocateVex(G,w);/*w1为w在G中的位置*/
	p=G.vertices[v1].firstarc;
	while(p&&p->adjvex!=w1)
		p=p->nextarc;
	if(!p||!p->nextarc)
		return -1 ;
	else   /*p->adjvex=w1*/
		return p->nextarc->adjvex;
}

void InsertVex(ALGraph *G, VertexType v){
	/*初始条件:图G存在,v和图中顶点相同特征*/
	/*操作结果:在图G中增添顶点，不添加与顶点相关的弧，招待InsertArc去做*/
	strcpy(	G->vertices[G->vexnum].data , v);
	G->vertices[G->vexnum].firstarc = NULL;
	G->vexnum++;   /*图G的顶点数加1*/
}

Status DeleteVex(ALGraph *G, VertexType v){
	/*初始条件:图G存在,v是图G中的某个顶点*/
	/*操作结果:删除G中的顶点v*/
	int i,j;
	ArcNode *p,*q ;
	j = LocateVex(*G,v);
	if(j<0) /*v不是图G中的顶点*/
		return -1;
	p=G->vertices[j].firstarc;/*删除以v为出度的节点*/
	while(p){
		q=p;
		p=p->nextarc;
		if(G->kind%2)/*网*/
			free(q->info);
		free(q);
		G->arcnum--;/*弧或边减少1*/
	}
	for(i=j;i<G->vexnum;i++)
		G->vertices[i]=G->vertices[i+1];/*顶点数组向前移*/
	G->vexnum--;/*顶点减少1*/
	for(i=0;i<G->vexnum;i++){/*删除以v为入度的弧或边且必要的时候修改表节点的顶点的位置*/
		p=G->vertices[i].firstarc;
		while(p){/*有弧*/
			if(p->adjvex==j){
				if(p==G->vertices[i].firstarc){/*待删除的是第一个结点*/
					G->vertices[i].firstarc=p->nextarc;
					if(G->kind%2) /*网，则销毁info信息*/
						free(p->info);
					free(p);
					p=G->vertices[i].firstarc;
					if(G->kind<2)
						G->arcnum--;	
				}else{
					q->nextarc=p->nextarc;
					if(G->kind%2)
						free(p->info);
					free(p);
					p=q->nextarc;
					if(G->kind<2)
						G->arcnum--;
				}
			}else{
				if(p->adjvex>j)
					p->adjvex--;/*修改表结构的顶点位置值(序号)*/
				q=p;
				p=p->nextarc;
			}
		}
	}
	return OK;
}
Status InserArc(ALGraph *G, VertexType v,VertexType w){
	/*初始条件:图G存在,v,w是G中的两个顶点*/
	/*操作结果:在G曾增加<v,w>的一条弧，若是无向图则增加另一条<w,v>的弧*/
	ArcNode *p ;
	int w1,i,j ;

	i=LocateVex(*G,v);
	j=LocateVex(*G,w);
	if(i<0||j<0)
		return -1;
	G->arcnum++;
	if(G->kind%2){/*网*/
		printf("请输入弧(边)%s->%s的权值: ");
		scanf("%d",&w1);
	}

	p=(ArcNode*)malloc(sizeof(ArcNode));
	p->adjvex=j;
	if(G->kind%2){/*网*/
		p->info = (int *)malloc(sizeof(int));
		*(p->info)=w1;
	}else{
		p->info=NULL;
	}

	p->nextarc=G->vertices[i].firstarc;
	G->vertices[i].firstarc=p;
	if(G->kind>=2){/*无向，生成另一条表结点*/
		p=(ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex=i;
		if(G->kind==3){/*无向网*/
			p->info = (int *)malloc(sizeof(int));
			*(p->info)=w1;
		}else{
			p->info=NULL;
		}
		p->nextarc=G->vertices[j].firstarc;
		G->vertices[j].firstarc=p;
	}
	return OK ;
}

Status DeleteArc(ALGraph *G,VertexType v,VertexType w){
	/*初始条件:图G存在,v和w分别是G中的顶点*/
	/*操作结果:删除G中<v,w>的弧或边,若是无向图,则删除另一条<w,v>的边或弧*/
	int i,j;
	ArcNode *p,*q;
	i=LocateVex(*G,v);
	j=LocateVex(*G,w);
	//健壮性判断
	if(i<0||j<0||i==j)
		return -1;
	p=G->vertices[i].firstarc;/*指向顶点v的第一条弧*/
	while(p&&p->adjvex!=j){
		q=p;
		p=p->nextarc;
	}
	if(p&&p->adjvex==j)/*找到弧<v,w>*/
	{
		/*分两种情况分别处理:1.是第一个邻接点2.是后面的邻接点*/
		if(p==G->vertices[i].firstarc){
			G->vertices[i].firstarc=p->nextarc;
		}else{
			q->nextarc=p->nextarc;
		}
		if(G->kind%2)
			free(p->info);
		free(p);
		G->arcnum--;

	}
	if(G->kind>=2){//无向图或网
		p=G->vertices[j].firstarc;/*指向w的第一条弧或边*/
		while(p&&p->adjvex!=i){
			q=p;
			p=p->nextarc;
		}

		if(p&&p->adjvex==i){
			if(p==G->vertices[j].firstarc)
				G->vertices[j].firstarc= p->nextarc;
			else
				q->nextarc=p->nextarc;
			if(G->kind==3)
				free(p->info);
			free(p);
		}
	}
	return OK ;
}

bool visited[MAX_VEX_NUM] ;
void DFS(ALGraph G,int v){
	int w ;
	VertexType v1,w1;
	strcpy(v1,*GetVex(G,v));
	visited[v]=true;/*标志已经访问*/

	Visit(G.vertices[v].data);
	for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,*GetVex(G,w))))
		if(!visited[w])
			DFS(G,w);
}
void DFSTraverse(ALGraph G){
	/*对图深度优先遍历*/
	int v;/*顶点的序号*/

	for(v=0;v<G.vexnum;v++){
		visited[v]=false;
	}

	for(v=0;v<G.vexnum;v++)
		if(!visited[v])
			DFS(G,v);
		printf("\n");
}

void BFSTraverse(ALGraph G){
	/*广度优先搜索(非递归),需要一个辅助队列Q和访问标志visited[]数组*/
	int v,u,w ;
	VertexType u1,w1 ;
	LinkQueue Q ;
	for(v=0;v<G.vexnum;v++){
		visited[v]=false;
	}
	InitQueue(Q);
	for(v=0;v<G.vexnum;v++){/*若是连通图,v=0就能遍历全部顶点*/
		if(!visited[v]){
			visited[v]= true;
			Visit(G.vertices[v].data);
			EnQueue(Q,v);
			while(!IsEmpty(Q)){/*队列不空*/
				DeQueue(Q,u);
				strcpy(u1,*GetVex(G,u));
				for(w=FirstAdjVex(G,u1);w>=0;w=NextAdjVex(G,u1,strcpy(w1,*GetVex(G,w)))){
					if(!visited[w]){
						visited[w]=true;
						Visit(G.vertices[w].data);
						EnQueue(Q,w);
					}
				}
			}
		}
	}
	printf("\n");
}

/***************最小生成树算法*************/
int minimum(ALGraph G,closedge MinEdge){  //寻找V中各节点到U中各节点间最小的权值，返回结点的编号  
    int i,j,first,min;  
    for(i=0;i<G.vexnum;i++){  /*获得MinEdge中第一个lowcost不为0的位置*/
        if(MinEdge[i].lowcost!=0){  //MinEdge[i].lowcost==0说明编号为i的结点在U中  
            min=MinEdge[i].lowcost;  /*记当前的第一个lowcost不为0,默认为最小值*/
            first=i;  /*记住默认最小值的当前位置*/
            break;  
        }  
    }  
    k=i;  
    for(i=first;i<G.vexnum;i++){  /*循环遍历获得最小值为位置*/
        if(min>MinEdge[i].lowcost&&MinEdge[i].lowcost!=0){  
            min=MinEdge[i].lowcost;  
            k=i;  
        }  
    }  
    return k;  
}  
  
void MinSpanTree(ALGraph G,VertexType u){  //从图中结点u开始生成最小生成树的过程  
    int i,k;  
    ArcNode *p;  
    closedge MinEdge;  
    k=LocateVex(G,u);  
    for(i=0;i<G.vexnum;i++)  
        MinEdge[i].flag=0;  //访问标志初始化为0  
	/******初始化MinEdge数组*****/
	/*初始化的算法为:*/
    for(i=0;i<G.vexnum;i++){  
        if(i!=k){  
            strcpy(MinEdge[i].data,u);     
            for(p=G.vertices[i].firstarc;p!=NULL;p=p->nextarc){  
                if(p->adjvex==k){   //p->adjvex==k说明编号为i的结点与编号为k的结点间有弧连接，需要把MinEdge的lowcost修改为弧上的权值  
                    MinEdge[i].lowcost=*(p->info);  
                    MinEdge[i].flag=1;    //设置标志，表示编号为i的结点在这一过程中已更新过权值  
                }  
                else if(MinEdge[i].flag==0)    
                    MinEdge[i].lowcost=100;  
            }  
        }  
        strcpy(MinEdge[k].data,G.vertices[k].data);  
        MinEdge[k].lowcost=0;  
    }  
    for(i=1;i<G.vexnum;i++){  
        k=minimum(G,MinEdge); 
		printf("(%s-%s):%d",G.vertices[k].data,MinEdge[k].data,MinEdge[k].lowcost);
        
        MinEdge[k].lowcost=0;   //将结点加入U中  
        for(p=G.vertices[k].firstarc;p!=NULL;p=p->nextarc){  
            if(MinEdge[p->adjvex].lowcost>*(p->info)){  
                MinEdge[p->adjvex].lowcost=*(p->info);  
               strcpy( MinEdge[p->adjvex].data,G.vertices[k].data);  
            }  
        }  
    }  
}  
/******************************************/
void Display(ALGraph G){
	/*输出图的邻接矩阵*/
	int i ;
	ArcNode *p;
	switch(G.kind){
		case DG:printf("有向图\n");
			break;
		case DN:printf("有向网\n");
			break ;
		case AG:printf("无向图\n");
			break;
		case AN:printf("无向网\n");
			break;
	}
	printf("%d个顶点: \n",G.vexnum);

	for(i=0;i<G.vexnum;i++){
		printf("%s",G.vertices[i].data);
	}
	printf("\n%d条弧(边)",G.arcnum);
	for(i=0;i<G.vexnum;i++){
		p=G.vertices[i].firstarc;
		while(p){
			if(G.kind<=1){//有向
				printf("%s->%s",G.vertices[i].data,G.vertices[p->adjvex].data);
				if(G.kind==DN)/*网*/
					printf(":%d",*(p->info));
			}else{//无向
				if(i<p->adjvex){
					printf("%s-%s",G.vertices[i].data,G.vertices[p->adjvex].data);
					if(G.kind==AN)
						printf(":%d",*(p->info));
				}
			}
			p=p->nextarc;
		}
		printf("\n");
	}
}
void Visit(char str[]){
	printf("%s",str);
}
/*****************队列实现******************************/
Status InitQueue(LinkQueue &Q){
	Q.front = Q.rear=(QueuePtr)malloc(sizeof(QNode));
	if(!Q.front) exit(OVERFLOW);
	Q.front->next = NULL;
	return OK ;
}

Status EnQueue(LinkQueue &Q,QElemType e){
	QueuePtr p =NULL ;
	p= (QueuePtr)malloc(sizeof(QNode));
	if(!p) exit(OVERFLOW);

	p->data = e ;

	Q.rear->next=p;
	Q.rear = p;
	p->next=NULL;
	return OK ;
}

Status DeQueue(LinkQueue &Q,QElemType &e){
	if(Q.front==Q.rear) 
		return ERROR ;//队列为空
	QueuePtr p=NULL;
	p= Q.front->next;
	e= p->data ;
	Q.front->next = p->next;
	if(Q.rear==p) //队列中只有一个元素
		Q.rear=Q.front;
	free(p);
	return OK ;
}

Status DestroyQueue(LinkQueue &Q){
	while(Q.front){
		Q.rear = Q.front->next;
		free(Q.front);
		Q.front = Q.rear;
	}
	return OK ;
}

int QueueLength(LinkQueue Q){
	int length =0 ;
	QueuePtr p ;
	if(Q.front==Q.rear) return ERROR ;

	p= Q.front->next ;

	while(p!=NULL){
		length++ ;
		p=p->next ;
	}
	return length ;
}

bool IsEmpty(LinkQueue Q)//判断队列是否为空  
{  
    return Q.front == Q.rear ? true : false;  
}  
/*****************************************************************/

void main(){
	ALGraph G ;
	CreateGraph(&G);
	Display(G) ;
//	printf("%c",GetVex(G,3));
//	Destory(&G);
//	Display(G) ;
//	PutVex(&G,'A','F');
//	Display(G) ;
//	int i= FirstAdjVex(G,"B");
//	printf("pos=%d:value=%s\n",i,G.vertices[i].data);

//	int i=NextAdjVex(G,"A","C");
//	printf("pos=%d:value=%s\n",i,G.vertices[i].data);

//	InsertVex(&G, "E");
//	Display(G);

//	DeleteVex(&G,"A");
//	Display(G);

//	InserArc(&G,"C","D");
//	Display(G);

	DFSTraverse(G);
	BFSTraverse(G);

	MinSpanTree(G,"v1");
}
 

 


 
 

有向图，十字链表实现：
 

http://www.cnblogs.com/cpoint/p/3480214.html

                

        

    

  



    



                



	

		

			

				
					
线性表的链式存储结构和实现

				
			

			

				

					leecam的博客
				

				

					05-22
					
					1113
					
				

			

		

		

			
				
若front指向最后一个结点，有front.next=null，在front结点后插入一个结点，也可执行上述中间插入程序段，所以尾插入是中间插入的特例，中间插入或尾插入都不会改变单链表的头指针head。线性表采用链式存储结构，称为线性链表（Linked List），逻辑上相邻的元素是分散存储的，因此必须采用指针变量记载前驱或者后继元素的地址，来存储元素之间的线性关系。遍历单链表时从第0个结点开始，沿着结点的next链，依次访问单链表中每个结点，并且每个结点只访问一次。结点（结点域，地址域）

			
		

	



                

            
              



	

		

			

				
					
图的链式存储结构解析（邻接表、逆邻接表、十字链表、邻接多重表）

				
			

			

				

					LRY89757的博客
				

				

					07-07
					
					1万+
					
				

			

		

		

			
				
图的矩阵表示法比较消耗空间，需要花费$n2n^2n2$个单元存储边（弧）。在边数较少的情况下比较浪费。我们这里来讨论图的链式存储结构。
图的链式结构主要有四类：邻接表、逆邻接表、十字链表、邻接多重表。
前两个算比较好理解的，后两个更复杂一点。
目录邻接表无向图的邻接表有向图的邻接表逆邻接表十字链表存储结构构造十字链表十字链表结构性质邻接多重表存储结构构造邻接多重表
邻接表

实际上邻接表都是使用数组来存储顶点，然后对每一个顶点建立一个单链表，第i个但链表中的节点表示依附于顶点vi的边（对有向图是以vi为尾的

			
		

	



              


  
              

                


	

		

			

				
					
数据结构-图的链式存储

				
			

			

				

					03-19
				

			

		

		

			
				
数据结构
c语言实现图的链式存储
供初学者研究使用
仅供参考

			
		

	





	

		

			

				
					
图的链式存储

				
			

			

				

					江河湖海
				

				

					10-29
					
					959
					
				

			

		

		

			
				
输入两个数字，代表图的顶点数和边数 n , e

后面 n 行，每一行的第一个数字 ve 代表与这个顶点相邻的点的个数
后面 ve 个数，代表与这个数字相邻点的编号（从0开始）

//#include 
#include
//typedef enum {false, true} bool;
#define MaxVertexNum 10   /* 最大顶点数设为10 */
typedef

			
		

	



		

			
		



	

		

			

				
					
细说链式存储结构

					
热门推荐

				
			

			

				

					Ron.Zheng
				

				

					10-13
					
					2万+
					
				

			

		

		

			
				
提起链式存储结构，其与数组是两个非常基础的数据结构，每当提到链式存储结构时，一般情况下我们都会将其与数组放到一块儿来比较。
对于数组与链表，从结构上来看，数组是需要一块连续的内存空间来存储数据，对内存的要求非常高，比如说我们申请一个100M大小的数组，而如果我们的内存可用空间大于100M，但是没有连续的100M可用空间，那即便是我们的内存空间充足，在申请空间时也会申请失败。
而对于链表来说，他对内...

			
		

	





	

		

			

				
					
图的存储（链式前向星）

				
			

			

				

					智障
				

				

					08-18
					
					4986
					
				

			

		

		

			
				
/*所谓的这种存储边的方法，就是邻接链表在的静态实现（人称：池子法）
 *就是比较省时间开销
 */
#include 
#include 
#define MAXM 1000005
#define MAXN 10005
struct node {
    int v, w, pre;
}edge[MAXM<<1];
int p[MAXN], nEdge;  //p每个点相关边的起始位置，nEdg

			
		

	





	

		

			

				
					
图的链式存储(线性表)

				
			

			

				

					binyanye1的专栏
				

				

					10-06
					
					834
					
				

			

		

		

			
				
typedef struct ArcNode{ int adjvex;    //该弧所指向的顶点的位置 struct ArcNode *nextarc;//指向下一条弧的指针 InfoType *info;//该弧相关信息的指针}ArcNode;typedef struct VNode{ VertexType data;//顶点信息 ArcNode *firstarc

			
		

	





	

		

			

				
					
线性表的顺序存储结构、链式存储结构上的基本操作

				
			

			

				

					12-19
				

			

		

		

			
				
在本主题中，我们将深入探讨线性表的两种主要存储结构：顺序存储结构和链式存储结构，以及在这两种结构上实现的基本操作。同时，我们还会涉及栈这种特殊类型的线性表及其顺序和链式存储结构。  一、线性表的顺序存储...

			
		

	





	

		

			

				
					
线性表的链式存储结构

				
			

			

				

					03-28
				

			

		

		

			
				
线性表是计算机科学中一种基础的数据结构，它是由相同类型元素...理解并熟练掌握链式存储结构及其操作，对于学习更复杂的数据结构如树、图等都至关重要。在实际编程中，合理利用链表可以提高程序的运行效率和灵活性。

			
		

	





	

		

			

				
					
链式存储二叉树基本操作函数.rar

				
			

			

				

					03-28
				

			

		

		

			
				
2. **链式存储结构**：每个节点包含两个指针，分别指向其左子节点和右子节点。这种结构允许我们仅用少量额外空间来链接相邻节点，形成一个非顺序的树形结构。  3. **二叉树创建**：创建链式存储的二叉树通常涉及初始...

			
		

	





	

		

			

				
					
c语言数据结构实验：掌握线性表的链式存储结构 熟练掌握循环链表的存储特征和建立方法，掌握线性表的链式存储结构 下面是源码的txt

				
			

			

				

					10-13
				

			

		

		

			
				
01 02 03分别代表三个题 每个实验只有前两个题写了~ 运行都没有问题~  已知带头结点的动态单链表L中的结点是按整数值递增排序的，试写一算法将值为的结点插入到表L中，使L仍然有序。要求算法的时间复杂度为 O()，...

			
		

	





	

		

			

				
					
图的链式存储（邻接表）【摘录自严长生老师的网站】

				
			

			

				

					weixin_30420305的博客
				

				

					11-28
					
					277
					
				

			

		

		

			
				
当图比较稀疏时，采用邻接矩阵存储会比较浪费空间，因为大部分空间都会填充为0，这时候采用邻接表存储是一个可行方案。

如上图所示，每个顶点都是一个表头结点，data存放数据，fisrtarc是指向表中结点的指针，表中结点的adjvex存放该顶点的下标，nextarc是指向下一个表中结点的指针，info在图中可省略，在网中用来存储边的权重，info与nextarc交换一下更好一些。
以一个有向图...

			
		

	





	

		

			

				
					
数据结构与算法（九）图链式存储

					
最新发布

				
			

			

				

					2301_78838647的博客
				

				

					01-04
					
					2472
					
				

			

		

		

			
				
度：无向图的度：顶点与邻接点连接的边就做度。有向图的度：指向顶点的边叫做入度，由顶点指向其他邻接点的边叫做出度顶点：存储自身顶点信息和指向下一个临界点的指针邻接点：保存临接点的存储下标和下一个邻接点的指向指针存储方式：单向链接。

			
		

	





	

		

			

				
					
图的链式存储以及遍历各种操作

				
			

			

				

					
				

				

					05-26
					
					436
					
				

			

		

		

			
				
CodeBlocks编写


#include
using namespace std;

struct LinkNode
{
    int data;
    LinkNode *next;
};

struct node
{
   int num;
   LinkNode *first;
   int sum;
};
void chushihua(node* L,int n);

			
		

	





	

		

			

				
					
数据结构——图的链式存储结构实现

				
			

			

				

					赵满刚的博客
				

				

					11-24
					
					4077
					
				

			

		

		

			
				
一、邻接表Adiacency List（链式）表示法

对每个顶点vi 建立一个单链表，把与vi有关联的边的信息（即度或出度边）链接起来，表中每个结点都设为3个域；


 

 

每个单链表还应当附设一个头结点（设为2个域），存vi信息；
	每个单链表的头结点另外用顺序存储结构存储。
	对于任一确定的无向图邻接表不唯一
	邻接表的空间复杂度为O(n+e)，多用于稀疏图的存储（e&lt;&lt;n...

			
		

	





	

		

			

				
					
图的链式存储-邻接表笔记

				
			

			

				

					Charles梦想家
				

				

					11-29
					
					768
					
				

			

		

		

			
				
三个结构体表示邻接表
1.顶点头结点结构体
2.邻接点结构体
3.图的结构体

#include<iostream>
#include<queue>
#include<stack>
using namespace std

#include Maxvertex 50

//顶点结构体
  struct vertex
{
      char name[50];...

			
		

	





	

		

			

				
					
【图论】图的存储方式——链式向前星

				
			

			

				

					CAIBI WORID
				

				

					08-07
					
					3514
					
				

			

		

		

			
				
存储结构这是学的第三种了，在今天的练习赛中还用到了，可以说是很好的巩固了。

链式向前星是一种开始看不懂的结构，但理解了，挺好用的。

好吧，这个博客就是水的，我就想把这个链接记下来，防止丢了：

https://blog.youkuaiyun.com/qq_30331643/article/details/68621435

加一张图

...

			
		

	





	

		

			

				
					
（数据结构）二叉树的链式存储结构

				
			

			

				

					weixin_51927215的博客
				

				

					03-29
					
					1万+
					
				

			

		

		

			
				
二叉树的顺序存储的缺点

因为并不是每个二叉树都是完全二叉树，普通二叉树使用顺序表存储或多或少会存在空间浪费的现象



图 1 普通二叉树的转化

如上图 1，普通二叉树里只有二个元素，最好的存储方式当然是开辟相对应的空间，但是顺序存储结构却让我们不能这么做！也就是说我们此时必须花更多的空间去存储相对少的元素

二叉树的链式存储

先慢慢介绍一下链式存储的节点结构！！！



图 2 普通二叉树示意图

如上图 2 所示，若将其采用链式存储，则只需从树的根节点开始，将各个节点及其左右孩子使用链表存储

因

			
		

	





	

		

			

				
					
图论算法入门基础---图的储存---链式前向星详讲

				
			

			

				

					qq_63788960的博客
				

				

					03-06
					
					1120
					
				

			

		

		

			
				
接下来介绍三种图的储存方式：

1：邻接矩阵：优点：容易理解，实现简答，适用于稠密图（边多的图）；缺点不适合与稀疏图会造成巨大的空间浪费，是最暴力的方法了；

2：邻接表：优点与缺点都不突出，是算法竞赛中比较常用的做法；缺点是不易判定重边

3：链式前向星：缺点也是判重麻烦，还有就是难以理解，代码实现麻烦。要是理解后把代码模版背下来呢？  优点的话，据前人经验，几乎所有图论题都能用它做。这也是本文重点讲的。

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  

	
    

      

      

      

        
        

          
          

            

              成就一亿技术人!
            

            

              拼手气红包6.0元
            

          

        

        

          

            还能输入1000个字符
          

          

             
          

          

            

              红包
              添加红包
            

            

              表情包
              插入表情
              

                

              

            

            

              表情包
              代码片
              

                
              

            

            

              
              
              
              
              
              
              
            

          

        

      

    

		

			

			

			

					 条评论被折叠 查看
			

			

				
			

		

	

	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值