数据结构——线性表链式存储

已于 2023-10-15 21:06:51 修改
阅读量1.5k 收藏 24
点赞数 1
文章标签： 数据结构
于 2023-10-14 22:16:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51785373/article/details/133813703
版权

目录

一、链式存储结构定义

二、链表的介绍

三、循环链表的实现

1、循环链表的创键

2、 链表初始化

3、 插入算法（头插法）

4、 插入算法（尾插法）

5、 插入算法（位置i插入）

6、 查找元素

7、求链表长度

8、 输出元素

四、完整Demo 

五、小结 

六、参考文献 

一、链式存储结构定义

1、定义：线性表的存储方式分为顺序存储和链式存储。其中链式存储是指将线性表中的元素按照一定的次序链接起来，每个元素包含两个部分：数据域和指针域。其中，数据域用于存储元素的值，指针域用于指向下一个元素的地址。通过指针域之间的链接，可以将线性表中的元素连接成一条链式结构。

2、特点：

  • 结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻。
  • 访问时只能通过头指针进入链表，并通过每个结点的指针域依次向后顺序扫描其余结点，所以寻找到一个结点和最后一个结点所花费的时间不等。

二、链表的介绍

1、链表分为单链表、循环链表、双向链表 。 

  •  单链表： 每个结点只包含直接后继的地址信息，结点只有一个指针域的链表。
  • 循环链表：单链表的最后一个结点的直接后继为第一给结点（首尾相接）
  •  双向链表：单链表中的结点包含直接前驱和后继的地址信息（结点有两个指针域 ）                                   

链表中相关术语：

  1. 头结点：它是链表中的辅助结点，只包含指向第0个数据元素的指针，而没有数据信息，头结点有简化代码的作用，因为它始终指向了第0个元素，便于执行时对元素位置的定位。
  2. 尾结点：尾结点中存储的地址信息可以用于区分链表类型。尾指针为空：单链表。尾指针指向链表的开头：循环链表。为随机值：非法链表。
  3. 数据结点：它是链表中代表数据元素的结点，表现为数据域和指针域。
  4. 指针域：结点中存储数据元素之间的链接信息即下一个结点地址的部分。
  5. 数据域：结点中存储数据元素的部分。

三、循环链表的实现

1、循环链表的创键

​

循环链表是一种头尾相接的链表如上图，表中最后一个结点的指针域指向头结点，整个链表形成一个一个环状，循环链表与单链表类似，只不过单链表最后一个结点指向NULL.

/*简单链表的定义*/
typedef struct node    //声明结点的类型和指向结点的指针类型
{
	DataType		data;	/*数据域*/
	struct node		*next;	/*指针域*/
}SingleLinkList, SingleLinkNode;
2、 链表初始化

        单链表的初始化是指将一个空的单链表开辟一段连续的内存空间，生成新的结点作为头结点，用头指针指向头结点，并将头结点指针域置空。具体代码实现如下：

//init函数接受一个指针的指针SingleLinkList **Head 作为参数表示需要初始化单链表的头结点地址
int init(SingleLinkList **Head)   
{
	if(1)
	{
		/*使用malloc()函数为单链表分配一块空间，大小为 sizeof(SingleLinkList)*/
		(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
		/*判断内存申请是否成功*/
		if(*Head == NULL)
		{
			printf("申请内存错误， 初始化失败！[100001]\n");
			return 100001;
		}
        /*将头结点的next指针指向自身，即(*Head)->next=*Head*/
		(*Head)->next=*Head;
		/*单链表：(*Head)->next = NULL;*/
		/*循环链表：(*Head)->next = *Head;*/
		return 0;
	}
	else
	{
		printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
		return 100002;
	}
}
3、 插入算法（头插法）

        头插法是将新的元素插入到头结点的后面。具体是先将头结点与首节点联系断开，将首节点的地址（存放在头结点的指针域）赋给要插入的新节点的指针域，这样子新节点就和后面的所有节点连接了起来，起到了保护后面所有节点的作用； 然后将新节点的地址赋值给头结点的指针域，覆盖掉原本存放的首节点的地址，这样操作就完成了对链表的头结点插入元素。

/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x)
{
	SingleLinkNode *newNode;

	if(0)
	{
		printf("链表未初始化！[100003]\n");
		return 100003;
	}
	
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	if(!newNode)
	{
		printf("申请节点内存空间失败！[100004]\n");
		return 100004;
	}
	newNode->data = x;
	newNode->next = (*Head)->next;

	(*Head)->next = newNode;

	return 0;
}
4、 插入算法（尾插法）

        循环链表的尾部插入一个新元素和单链表尾部插入新元素有所不同，前者最后一个元素指向的是头结点，而单链表的最后一个元素指向的是NULL。先通过遍历找到一个指向链表头部的指针，然后修改尾结点的next指针，使其执行循环链表的头部，最后更新尾指针，使其指向新节点。

/*3. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x)
{
	SingleLinkNode *newNode;
	SingleLinkNode *p;

	if(0)
	{
		printf("链表未初始化！[100003]\n");
		return 100003;
	}
	
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	if(!newNode)
	{
		printf("申请节点内存空间失败！[100004]\n");
		return 100004;
	}

	newNode->data = x;
	/*单链表newNode->next = NULL;*/
	newNode->next=*Head;
	/*循环链表 newNode->next = *Head;*/

	p = (*Head);

	while(p->next==Head)
	{
		p = p->next;
	}

	p->next = newNode;

	return 0;
}
5、 插入算法（位置i插入）

        首先，定义一个指针变量，初始化为头结点，需要找到插入节点的前一个节点。因为，要插入的位置的前一个节点保存了要插入位置的后一个节点的地址知道了后面节点的地址才能对其进行操作。

/*4. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x)
{
	int j;
	SingleLinkNode *p;
	SingleLinkNode *newNode;

	
	/*对i进行判断，0<i<=length+1*/
	if(i<1 || i>length(*Head)+1)
	{
		printf("位置i不是链表有效位置！[100005]\n");
		return 100005;
	}
	p = (*Head);
	j = 1;

	while(j<i)
	{
		j++;
		p = p->next;
	}

	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	/*此处省略检测newNode是否申请成功*/

	newNode->data = x;
	newNode->next = p->next;
	p->next = newNode;
	return 0;
}
6、 查找元素

        通过一个循环来从链表头部开始遍历，找到所需元素。如果在遍历过程中找到了该元素，则返回该元素所在的结点。

/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x)
{
	int i;
	SingleLinkNode *p;

	i = 1;
	p = Head->next;

	while( p!= Head && p->data != x)  /*单链表while(p && p->data != x) */
	{
		i++;
		p = p->next;
	}

	if(p == Head)  /*单链表if(!p) */
	{
		return 0;
	}
	else
	{
		return i;
	}

}
7、求链表长度

        循环链表是一种特殊的链表，其最后一个节点的next域不是NULL，而是指向头节点。因此，循环链表的长度是指从头节点开始，到某个节点再次回到头节点所经过的结点数。如果从头节点开始，经过n个结点后再次回到头节点，则循环链表的长度为n。

/*6. 链表长度*/
int length(SingleLinkList *Head)
{
	int len=0;
	SingleLinkNode *p;

	p = Head->next;
	while(p!=Head) /*单链表*while(p)*/	
	{
		len++;
		p = p->next;
	}
	return len;
}
8、 输出元素

        通过指针的移动来访问链表的每一个结点，链表的结束遍历标志为遍历到尾结点，即当一个结点的指针域为Head的时候，就找到了尾结点，链表的遍历也就完成了，输出结果完成。

/*7.输出链表*/
void print(SingleLinkList *Head)
{
	SingleLinkNode *p;
	int i=0;

	p = Head->next;
	if(p==Head)/*单链表if(!p)*/			
	{
		printf("链表为空！\n");
		return;
	}
	while(p!=Head)/*while(p)*/ 
	{
		printf("Node[%d]. = %d\n", ++i, p->data);
		p = p->next;
	}
}

四、完整Demo 

(1)main.c

#include <stdio.h>
#include <string.h>
#include "SingleLinkList.h"
#include <stdlib.h>
#include "welcome.h"


int main(int argc, char* argv[])
{
	SingleLinkList *Head;
	DataType x;
	int i,m,n,cmd;

	for(i=0;i<strlen(welcome);i++)
	{
		printf("%c",welcome[i]);
		for(m=0;m<1000;m++)
			for(n=0;n<1000;n++)
			{
				;
			}
	}

	printf("-----------简单链表演示程序----------\n");
	do
	{
		printf("1. 初始化链表表\n");
		printf("2. 插入元素（头插法）\n");
		printf("3. 插入元素（尾插法）\n");
		printf("4. 插入元素（在位置i插入）\n");
		printf("5. 查找元素x\n");
		printf("6. 求链表长度\n");
		printf("7. 输出链表\n");
		printf("8. 删除元素\n");
		printf("10. 帮助\n"); 
		printf("0. 退出\n");
		printf("请输入您要进行的操作（1~6,0退出）：");
		scanf("%d", &cmd);
		switch(cmd)
		{
		case 1:
			if(!init(&Head))
			{
				printf("链表已初始化！\n");
			}
			break;
		case 2:
			printf("请输入插入元素x：x=");
			scanf("%d",&x);
			if(!insert_head(&Head,x))
			{
				printf("元素（%d）已插入\n", x);
			}
			break;
		case 3:
			printf("请输入插入元素x：x=");
			scanf("%d",&x);
			if(!insert_tail(&Head,x))
			{
				printf("元素（%d）已插入\n", x);
			}
			break;
		case 4:
			printf("请输入插入元素位置i和元素x（i，x）：");
			scanf("%d,%d", &i, &x);
			if(!insert(&Head, i, x))
			{
				printf("已在位置（%d）插入元素（%d）！\n",i, x);
			}
			break;
		case 5:
			printf("请输入要查找的元素x：");
			scanf("%d", &x);
			if(i = find(Head,x))
			{
				printf("元素%d存在，在链表位置%d.\n", x, i);
			}
			else
			{
				printf("在链表中未找到元素x。\n");
			}
			break;
		case 6:
			printf("链表的长度为：%d\n", length(Head));
			break;
		case 7:
			print(Head);
			break;
		case 8:
			printf("请输入要删除的元素x：");
			scanf("%d", &x);
			if(!delete(&Head, x))
			{
				printf("元素x【%d】已删除!\n", x);
			}
			break;
		case 10:
			
			printf(" 本程序为链表的演示程序，有ZZB设计开发，程序完成了循环表插入、删除、查找等功能！\n");
			break;
			
		}
	}while(cmd != 0);

	return 0;
}

（2）SingleLinkList.c

/*
	SingleLinkList.c
	
*/
#include "SingleLinkList.h"
#include <stdlib.h>
#include <stdio.h>
/*#include<stdbool.h>*/

/*1. 初始化*/
int init(SingleLinkList **Head)
{
	if(1)
	{
		/*申请内存*/
		(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
		/*判断内存申请是否成功*/
		if(*Head == NULL)
		{
			printf("申请内存错误， 初始化失败！[100001]\n");
			return 100001;
		}
		(*Head)->next=*Head;
		/*单链表：(*Head)->next = NULL;*/
		/*循环链表：(*Head)->next = *Head;*/
		return 0;
	}
	else
	{
		printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
		return 100002;
	}
}


/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x)
{
	SingleLinkNode *newNode;

	if(0)
	{
		printf("链表未初始化！[100003]\n");
		return 100003;
	}
	
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	if(!newNode)
	{
		printf("申请节点内存空间失败！[100004]\n");
		return 100004;
	}
	newNode->data = x;
	newNode->next = (*Head)->next;

	(*Head)->next = newNode;

	return 0;
}


/*2. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x)
{
	SingleLinkNode *newNode;
	SingleLinkNode *p;

	if(0)
	{
		printf("链表未初始化！[100003]\n");
		return 100003;
	}
	
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	if(!newNode)
	{
		printf("申请节点内存空间失败！[100004]\n");
		return 100004;
	}

	newNode->data = x;
	/*单链表newNode->next = NULL;*/
	newNode->next=*Head;
	/*循环链表 newNode->next = *Head;*/

	p = (*Head);

	while(p->next==Head)
	{
		p = p->next;
	}

	p->next = newNode;

	return 0;
}


/*3. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x)
{
	int j;
	SingleLinkNode *p;
	SingleLinkNode *newNode;

	
	/*对i进行判断，0<i<=length+1*/
	if(i<1 || i>length(*Head)+1)
	{
		printf("位置i不是链表有效位置！[100005]\n");
		return 100005;
	}
	p = (*Head);
	j = 1;

	while(j<i)
	{
		j++;
		p = p->next;
	}

	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	/*此处省略检测newNode是否申请成功*/

	newNode->data = x;
	newNode->next = p->next;
	p->next = newNode;
	return 0;
}


/*4. 删除元素, 删除值为x的元素*/
int delete(SingleLinkList **Head, DataType x)
{
	int i;
	int j;

	SingleLinkNode *p;
	SingleLinkNode *q; /*要删除的元素x*/

	i = find(*Head,x);
	if(!i)
	{
		printf("元素x【%d】不存在！100006\n", x);
		return 100006;
	}
	
	p = (*Head);
	j=1;

	while(j<i)
	{
		j++;
		p = p->next;
	}
	
	q = p->next;
	p->next = q->next;

	free(q); /*释放内存*/

	return 0;
}


/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x)
{
	int i;
	SingleLinkNode *p;

	i = 1;
	p = Head->next;

	while( p!= Head && p->data != x)  /*单链表 while(p && p->data != x)*/
	{
		i++;
		p = p->next;
	}

	if(p == Head)  /*单链表if(!p) */
	{
		return 0;
	}
	else
	{
		return i;
	}

}

/*6. 链表长度*/
int length(SingleLinkList *Head)
{
	int len=0;
	SingleLinkNode *p;

	p = Head->next;
	while(p!=Head) /*单链表*while(p)*/	
	{
		len++;
		p = p->next;
	}
	return len;
}

/*7.输出链表*/
void print(SingleLinkList *Head)
{
	SingleLinkNode *p;
	int i=0;

	p = Head->next;
	if(p==Head)/*单链表if(!p)*/			
	{
		printf("链表为空！\n");
		return;
	}
	while(p!=Head)/*while(p)*/ 
	{
		printf("Node[%d]. = %d\n", ++i, p->data);
		p = p->next;
	}
}

（3）SingleLinkList.h 

/*
	SingleLinkList.h
*/

typedef int DataType;

/*简单链表的定义*/
typedef struct node
{
	DataType		data;	/*数据域*/
	struct node		*next;	/*指针域*/
}SingleLinkList, SingleLinkNode;


/*1. 初始化*/
int init(SingleLinkList **Head);

/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x);

/*2. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x);

/*2. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x);

/*3. 删除元素, 删除值为x的元素*/
int delete(SingleLinkList **Head, DataType x);

/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x);

/*6. 求链表的长度 */
int length(SingleLinkList *Head);

/*7.输出链表*/
void print(SingleLinkList *Head);

（4）welcome.h 

char welcome[] = "\n\
           /\ \n\
          ( *)======/\==== \n\
           )(      /  \ \n\
__________/  )    /    \ \n\
\___         /   / \"\"   \ \n\
  \____    _/   / (**)   \ \n\
     / \__/    (----------) \n\
    /____|__//_ ( 本程序 ) \n\
         |       ( 由ZZB) \n\
         |       ( 开发 )\n\
         |        (____)\n\
        _|__\n\
         \\    ☆新年 . 快乐☆\n\n";

 10.运行结果

 ​ 

五、小结 

  1. 循环链表的任意元素都有一个前驱和一个后继，所有数据元素在关系上构成逻辑上的环。循环链表是一种特殊的单链表，尾结点的指针指向首结点的地址。

  2. 结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻。
  3. 访问时只能通过头指针进入链表，并通过每个结点的指针域依次向后顺序扫描其余结点，所以寻找到一个结点和最后一个结点所花费的时间不等。

六、参考文献 

《数据结构》(C语言版）李刚，刘万辉.北京：高等教育出版社 ，2017.   

《C语言程序设计》(第四版）谭浩强. 北京：清华大学出版社，2014.

  CSDN 数据结构-----循环链表

清风明月01
关注
  • 1
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构（四） — 线性表之链式存储
dashifu11111的博客
03-26 2903
一、线性表的链式存储结构 1、线性表链式存储结构定义 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。这就意味着，这些数据元素可以存在内存未被占用的任意位置。 以前在顺序结构中，每个数据元素只需要存数据元素信息就可以了。现在链式结构中，除了要存数据元素信息外， 还要存储它的后继元素的存储地址。 因此，为了...
线性表的链式存储结构
weixin_43887148的博客
10-22 2357
单链表（线性表的链式存储） 顺序存储结构不足的解决办法 前面我们讲的线性表的顺序存储结构。它是有缺点的，最大的缺点就是插入和删除时需要移动大量元素，这显然就需要耗费时间。能不能想办法解决呢? 要解决这个问题，我们就得考虑一下导致这个问题的原因。 为什么当插入和删除时，就要移动大量元素，仔细分析后，发现原因就在于相邻两元素的存储位置也具有邻居关系。它们编号是1，2，3，…， n，它们在内存中的位置也是挨着的，中间没有空隙，当然就无法快速介入，而删除后，当中就会留出空隙，自然需要弥补。问题就出在这里。 使用数组
数据结构——线性表（链式存储结构）
最新发布
qq_55869380的博客
04-09 1506
链表的13种操作 实现思路和代码
初学数据结构——从零开始的数据结构学习第五天（线性表的链式存储方式）
Lazy_ChessPlayer的博客
04-10 2211
本博客为本人在学习数据结构路途上的知识整理，如觉得对有你有所帮助，还希望留下一个赞。由于博主只是一名大一新生，如果博文中出现错误，欢迎指正。如果想要转载，附上链接就行。线性表中各个数据元素在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻。线性表的链式表示又称为非顺序映像或链式映像。一种头尾相接的链表（即：表中最后一个结点的指针域指向头结点，整个链表形成一个环）在单链表的每个结点单再增加一个指向其直接前驱的指针域prior，这样链表中就形成了有两个方向不同的链，故称为双向链表。
链式存储结构
qq_58138249的博客
10-15 525
循环链表是一种特殊的链表数据结构，与单向链表或双向链表相比，循环链表的最后一个节点的下一个节点指向第一个节点，从而形成一个环形结构。因此，循环链表可以在最后一个节点后继续添加节点，并且可以像单向链表或双向链表一样遍历、查找和删除节点。循环链表通常有一个头指针和一个尾指针，它们指向第一个节点和最后一个节点，以便在添加或删除节点时快速定位。循环链表可以用于解决某些问题，例如模拟一个环形队列，或者用于实现循环播放的音乐列表等。
链式存储
weixin_56839811的博客
04-18 1195
链式存储: 将数据元素存储在一组任意的存储单位中，而应附加的指针表示元素之间的逻辑关系，因此得到的存储表示为链式存储。 存储结构的每个节点都有两部分组成，数据域和指针与其说数据存放元素。本身的数据指针域存放指针。 数据类型: 1.原子类型:每一对象仅由单值构成的类型，其值不可分解。 2.结构类型:每一对象可由若干个成分按某种结构不同可分成若干成分或称分量 抽象数据类型一般可以由数据对象、数据关系及基本操作三个要素定义 抽象数据类型可以用以下三元组表示: ADT=(D、S、P） 其中D是数据对象，用数据元素的
线性表链式存储
09-29
线性表是计算机科学中一种基础的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。在实际应用中，线性表的数据元素可以是整型、字符型或其他复杂的数据类型。线性表的链式存储是线性表的一种存储方式，与...
5.线性表链式存储结构.pdf
05-21
5.线性表链式存储结构.pdf
C++实现线性表链式存储（单链）
08-19
"C++实现线性表链式存储（单链）" 本文主要介绍了C++实现线性表链式存储的方法，包括了链表的定义、构造函数、插入结点、删除结点、查找结点等基本操作。下面是对该实现的详细分析： 一、链表的定义 在C++中，...
dm03_线性表链式存储设计与实现.zip_数据结构（C语言）
09-23
数据结构（C语言版）线性表的链式存储设计与实现（完整代码）
数据结构--线性表的链式存储
XUN__MLF的博客
02-24 2177
链式存储相关术语： 数据域：存储元素数值数据 指针域：存储直接后继结点的存储位置 结点：数据元素的存储映像。又1数据域和指针域两部分组成 链表：n个结点由指针链组成一个链表 单链表，双链表，循环链表 结点只有一个指针域的链表，称为单链表或线性链表 结点有两个指针域的链表，称为双链表 首尾相接的链表称为循环链表 头指针、头结点、和首元结点 头指针：是指向链表中第一个结点的指针 首元结点：是指链表中
【数据结构】线性表2——线性表的链式表示和实现（单链表）
FishC的博客
10-15 690
【数据结构】线性表2——线性表的链式表示和实现（单链表）
线性表的链式存储结构 ( 链表 )
qq_59708493的博客
11-09 3557
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
2.线性表的链式存储结构————单链表（思路分析，C语言、C++完整程序）
隔壁老王的博客
08-12 7407
目录 1.单链表的基本概念 2.单链表的基本操作 3.单链表编程实现----C语言 4.单链表编程实现----C++ 5.实验结果 1.单链表的基本概念 （1）单链表：当链表中的每个结点只含有一个指针域时，称为单链表。 （2）头指针：如上图所示，链表中第一个结点的存储位置叫做头指针。 （3）头结点：头结点是放在第一个元素结点之前的结点，头结点不是链表中的必须元素，其数据域一般...
什么是计算机链式储存应用,链式存储和顺序存储区别
weixin_33514864的博客
07-31 2064
语音内容：大家好，我是时间财富网智能客服时间君，上述问题将由我为大家进行解答。链式存储和顺序存储的区别是：1、链表存储结构的内存地址不一定是连续的，但顺序存储结构的内存地址一定是连续的；2、链式存储适用于在较频繁地插入、删除、更新元素时，而顺序存储结构适用于频繁查询时使用。链式存储结构，又叫链接存储结构。在计算机中用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的，也可以是不连续的...
数据结构-实验一 链式存储结构的基本操作
热门推荐
brandong
09-09 1万+
广州大学学生实验报告 开课实验室：计算机科学与工程实验（电子楼417）     2018年5月09日 学院 计算机科学与教育软件学院 年级、专业、班 网络161 姓名 卟咚君 学号 1606100*** 实验课程名...
数据结构---顺序结构与链式结构
qq_39112101的博客
03-14 4831
什么是数据结构，上图： 数据结构有两种存储方式： （1）顺序结构 （2）链式结构 为什么会这样呢？ 主要原因在于内存空间的连续与不连续，连续的就是顺序结构，如列表，下标就体现了列表的连续性，一个接一个。 但是内存空间要不可能都是连续的，哪些分散的空间也要使用，这个时候怎么办呢？ 这就需要一条绳子或者链子把他们连接起来，于是，这就有了链表。 链式结构分为...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值