线性表-链式存储

最新推荐文章于 2024-04-09 19:53:40 发布
最新推荐文章于 2024-04-09 19:53:40 发布
阅读量493 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39373989/article/details/82496492
版权

由上节我们可以发现顺序存储中插入和删除的时间复杂度为O（n），存入和读取为O（1），所以它适合不经常插入和删除的场合。

优点：可以快速地存取表中任意位置的元素

缺点：插入和删除时需要移动大量的元素，容易造成存储空间的“碎片”

线性表的链式存储结构

不同于顺序存储时需要连续的存储空间，链式存储可以用任意的未被存储的存储单元存储线性表的数据元素。顺序存储时每个元素只需要存储一个位置，链式存储除了存储元素信息外，还要存储它后继元素的地址（用指针实现）。

下图为线性表的链式存储结构示意图：

 

一个结点由两部分组成，数据域和指针域，由名字可知分别存储数据和后继结点的地址。

链表也跟线性表相似，有头有尾，链表中的头结点称为头指针，最后一个结点的指针为空（null）。

头结点的数据域一般不存储任何信息，无论链表是否为空，头指针均不为空，头指针是 链表的必要元素。

在链表的插入过程中可以分为三种情况：头插法，尾插法和普通从中间插入的方法，根据下面的图我们来看一下程序的代码：

Status insertHead(LinkList *L, ElemType e) {
	//头插法插入元素
	Node *n = (Node*)malloc(sizeof(Node));
	n->data = e;
	if (L->data == 0) {//在链表为空的情况下，如果第一个元素的进入是头插法，那么它是目前的尾指针
		r = L;//重新初始化尾指针
		n->next = r->next;
		r->next = n;
		r = n;
	}
	else {
		n->next = L->next;
		L->next = n;
	}
	L->data++;
	return OK;
}
Status insertTail(LinkList *L, ElemType e) {
	//尾插法插入元素
	Node *n = (Node*)malloc(sizeof(Node));
	n->data = e;
	n->next = r->next;
	r->next = n;
	r = n; 
	L->data++;
	return OK;
}

 

下面为正常插入时的代码：

Node *n = (Node*)malloc(sizeof(Node));
		n->data = e;
		Node *p = L;
		for (int i = 1; i < position; i++) {
			p = p->next;
		}
		n->next = p->next;
		p->next = n;
		L->data++;

同样的，删除也有三种情况，我们来看一下代码：

 

Status deleteHead(LinkList *L, ElemType *e) {
	//删除头元素
	if (L->data == 0) {
		printf("单链表为空!\n");
		return ERROR;
	}
	Node *n = L->next;
	L->next = n->next;
	*e = L->data;
	free(n);
	L->data--;
	if (L->data == 0) {
		r = L;
	}
	return OK;
}

Status deleteTail(LinkList *L, ElemType *e) {
	//删除尾元素
	if (L->data == 0) {
		printf("单链表为空!\n");
		return ERROR;
	}
	Node *p = L;
	while (p->next != r) {
		p = p->next;
	}
	Node *n = p->next;
	p->next = n->next;
	*e = n->data;
	free(n);
	L->data--;
	r = p;
	return OK;
}

 

正常删除元素时如图所示：

Node *p = L;
		for (int i = 1; i < position; i++) {
			p = p->next;
		}
		Node *n = p->next;
		p->next = n->next;
		*e = n->data;
		free(n);
		L->data--;

综上：

线性表的链式存储和上节的顺序存储比较，根据时间复杂度，我们可以总结：若线性表需要频繁查找，很少进行插入和删除操作，宜采用顺序存储结构。 若需要频繁插入和删除时，宜采用链式存储结构。

下面还有实现的其他功能，我把整个代码放上来，大家可以运行理解一下！

强调一下，小编是用vs2017编译运行的，如果大家使用的编译器不一样，可以做一些修改。

#include<stdio.h>
#include<stdlib.h>
#define OK 1  //返回状态 成功
#define ERROR 0  //返回状态 失败
#define TRUE 1  
#define FALSE 0  
typedef int ElemType;
typedef int Status;
typedef struct Node {
	ElemType data;//数据域
	struct Node *next;//指针域（存储后继结点地址）
}Node, LinkList;
Node *r;//尾指针
Status init(LinkList *L) {
	//初始化
	L->data = 0;
	L->next = NULL;
	r = L;
	for (int i = 1; i <= 5; i++) {
		Node *n = (Node*)malloc(sizeof(Node));
		n->data = i;
		/*n->next = r->next;
		r->next = n;
		r = n;*/
		n->next = L->next;
		L->next = n;
		if (L->data == 0) {
			r = n;
		}
		L->data++;
	}
	return OK;
}
Status insertHead(LinkList *L, ElemType e) {
	//头插法插入元素
	Node *n = (Node*)malloc(sizeof(Node));
	n->data = e;
	if (L->data == 0) {//在链表为空的情况下，如果第一个元素的进入是头插法，那么它是目前的尾指针
		r = L;//重新初始化尾指针
		n->next = r->next;
		r->next = n;
		r = n;
	}
	else {
		n->next = L->next;
		L->next = n;
	}
	L->data++;
	return OK;
}
Status insertTail(LinkList *L, ElemType e) {
	//尾插法插入元素
	Node *n = (Node*)malloc(sizeof(Node));
	n->data = e;
	n->next = r->next;
	r->next = n;
	r = n; 
	L->data++;
	return OK;
}
Status insert(LinkList *L, int position, ElemType e) {
	//插入元素
	if (position<1 || position>L->data + 1) {
		printf("插入位置非法！\n");
		return ERROR;
	}
	if (position == 1) {
		insertHead(L, e);//头插法
	}
	else if (position == L->data + 1) {
		insertTail(L, e);//尾插法
	}
	else {//正常插入
		Node *n = (Node*)malloc(sizeof(Node));
		n->data = e;
		Node *p = L;
		for (int i = 1; i < position; i++) {
			p = p->next;
		}
		n->next = p->next;
		p->next = n;
		L->data++;
	}
	return OK;
}
Status deleteHead(LinkList *L, ElemType *e) {
	//删除头元素
	if (L->data == 0) {
		printf("单链表为空!\n");
		return ERROR;
	}
	Node *n = L->next;
	L->next = n->next;
	*e = L->data;
	free(n);
	L->data--;
	if (L->data == 0) {
		r = L;
	}
	return OK;
}
Status deleteTail(LinkList *L, ElemType *e) {
	//删除尾元素
	if (L->data == 0) {
		printf("单链表为空!\n");
		return ERROR;
	}
	Node *p = L;
	while (p->next != r) {
		p = p->next;
	}
	Node *n = p->next;
	p->next = n->next;
	*e = n->data;
	free(n);
	L->data--;
	r = p;
	return OK;
}
Status delete_L(LinkList *L, int position, ElemType *e) {
	//删除元素
	if (L->data == 0) {
		printf("单链表为空!\n");
		return ERROR;
	}
	if (position<1 || position>L->data) {
		printf("删除位置非法!\n");
		return ERROR;
	}
	if (position == 1) {//删头
		deleteHead(L, e);
	}
	else if (position == L->data) {//删尾
		deleteTail(L, e);
	}
	else {
		Node *p = L;
		for (int i = 1; i < position; i++) {
			p = p->next;
		}
		Node *n = p->next;
		p->next = n->next;
		*e = n->data;
		free(n);
		L->data--;
	}
	return OK;
}
Status getHead(LinkList *L, ElemType *e) {
	//获取头元素
	if (L->data == 0) {
		printf("单链表为空!\n");
		return ERROR;
	}
	*e = L->next->data;
	return OK;
}
Status getTail(LinkList *L, ElemType *e) {
	//获取尾元素
	if (L->data == 0) {
		printf("单链表为空!\n");
		return ERROR;
	}
	*e = r->data;
	return OK;
}
Status get(LinkList *L, int position, ElemType *e) {
	//获取位置所在元素
	if (L->data == 0) {
		printf("单链表为空!\n");
		return ERROR;
	}
	if (position<1 || position>L->data) {
		printf("位置非法！\n");
		return ERROR;
	}
	Node *p = L;
	for (int i = 1; i <= position; i++) {
		p = p->next;
	}
	*e = p->data;
	return OK;
}
Status get_locate(LinkList *L, ElemType e) {
	//获取元素所在位置
	int position = 0;
	if (L->data == 0) {
		printf("单链表为空!\n");
		return ERROR;
	}
	Node *p = L;
	while (1) {
		if (p == NULL) {
			printf("无此元素！\n");
			return ERROR;
		}
		if (p->data == e) {
			return position;
		}
		p = p->next;
		position++;
	}
	return OK;
}
int size(LinkList *L) {
	//获取长度
	return L->data;
}
void clear(LinkList *L) {
	//清空线性表
	if (L->data == 0) {
		printf("单链表为空!\n");
	}
	Node *p;
	while (L->next != NULL) {
		p = L->next;     //从头结点开始清空
		L->next = p->next;
		free(p);
		L->data--;
	}
	r = L;
	printf("该线性表已清空！\n");
}
Status empty(LinkList *L) {
	//判空线性表
	if (L -> data == 0) {
		return TRUE;
	}
	return FALSE;
}
void print(LinkList *L) {
	//打印线性表
	if (L->data == 0) {
		printf("[]\n");
		return;
	}
	printf("[");
	Node *p = L;
	while (1) {
		p = p->next;
		if (p->next == NULL) {
			printf("%d]", p->data);
			break;
		}
		else {
			printf("%d,", p->data);
		}
	}
	printf("\n");
}
int main()
{
	LinkList L;//创建一个头结点
	printf("----------线性表-------\n");
	printf("1、初始化操作\n");
	printf("2、插入元素\n");
	printf("3、删除元素\n");
	printf("4、获取头元素\n");
	printf("5、获取尾元素\n");
	printf("6、获取位置所在元素\n");
	printf("7、获取元素所在位置\n");
	printf("8、获取长度\n");
	printf("9、清空列表\n");
	printf("10、判空列表\n");
	printf("11、打印列表\n");
	printf("12、退出\n");
	printf("13、返回主菜单\n");
	printf("-------------------------\n");
	int choice;
	int position;
	ElemType e;
	while (1) {
		printf("请选择你想要的选项：\n");
		scanf_s("%d", &choice);
		switch (choice) {
			case 1:
				init(&L);
				break;
			case 2:
				printf("请输入要插入的位置：\n");
				scanf_s("%d", &position);
				printf("请输入要插入的元素：\n");
				scanf_s("%d", &e);
				insert(&L, position, e);
				break;
			case 3:
				printf("请输入要删除的位置：\n");
				scanf_s("%d", &position);
				if (delete_L(&L, position, &e)) {
					printf("删除的元素为：%d\n",e);
				}
				break;
			case 4:
				if (getHead(&L, &e)) {
					printf("该线性表的头元素为：%d\n", e);
				}
				break;
			case 5:
				if (getTail(&L, &e)) {
					printf("该线性表的尾元素为：%d\n", e);
				}
				break;
			case 6:
				printf("请输入查询的位置：");
				scanf_s("%d", &position);
				if (get(&L, position, &e) != ERROR) {
					printf("该位置的元素为：%d\n",e);
				}
				break;
			case 7:
				printf("请输入查询的元素：");
				scanf_s("%d", &e);	
				position = get_locate(&L, e);
				if ((position  != ERROR)) {
					printf("该元素的位置为：%d\n", position);
				}
				break;
			case 8:
				printf("该线性表长度为：%d\n", size(&L));
				break;
			case 9:
				clear(&L);
				break;
			case 10:
				if (empty(&L) == TRUE) {
					printf("单链表为空!\n");
				}
				else {
					printf("单链表不为空!\n");
				}
				break;
			case 11:
				print(&L);
				break;
			case 12:
				printf("已退出！\n");
				return 0;
			case 13:
				main();
				break;
			default:
				printf("输入错误！\n");
		}
	}
    return 0;
}

溪仔的阿宝呀
关注
专栏目录
数据结构——线性表链式存储
weixin_51785373的博客
10-14 2240
线性表的存储方式分为顺序存储和链式存储。其中链式存储是指将线性表中的元素按照一定的次序链接起来，每个元素包含两个部分：数据域和指针域。其中，数据域用于存储元素的值，指针域用于指向下一个元素的地址。通过指针域之间的链接，可以将线性表中的元素连接成一条链式结构。结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻。访问时只能通过头指针进入链表，并通过每个结点的指针域依次向后顺序扫描其余结点，所以寻找到一个结点和最后一个结点所花费的时间不等。1、链表分为单链表、循环链表、双向链表。
线性表链接存储
rengui1228的博客
01-04 599
以下是关于线性表链接存储（单链表）操作的11种算法   1.初始化线性表，即置单链表的表头指针为空   2.创建线性表，此函数输入负数终止读取数据  3.打印链表，链表的遍历  4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表   5.返回单链表的长度   6.检查单链表是否为空，若为空则返回１，否则返回０   7.返回单链表中第pos个结点中的元素，若
图说数据结构之线性表链式存储
君乙的博客专栏
04-25 436
本人在学习数据结构过程中的一点心得，与大家共享。 数据结构中的线性表顺序存储，在插入、删除数据时，需要移动表中其他数据，不够灵活。而链式存储的插入、删除操作都很方便。链式存储，顾名思义就是用一条链条将用户数据穿起来，在c语言中就是利用指针操作。 一、简单结构描述 简单的链式存储链中的节点由用户数据和一个指向下一个节点的指针组成。定义如下图所示： 存储数据后的结构形态如下图所示。 ...
线性表的链式存储
路在前方
07-11 204
线性表的链式存储 实验代码： #include<stdio.h> #include<stdlib.h> #define error 0 #define ok 1 typedef int elemtype; typedef struct SNode { elemtype data; struct SNode *next; }linkstack, *linklist; linklist init_linklist() //初始化 { linklist top; top =
数据结构——线性表（链式存储结构）
最新发布
qq_55869380的博客
04-09 2909
链表的13种操作 实现思路和代码
线性表-链式存储.c
04-10
中国大学MOOC上浙大的《数据结构》课程第一章线性表链式存储实现的代码。 包链表创建、插入、删除、排序、反序、查找等链表基本操作
数据结构实验报告2线性表的链式存储结构.pdf
09-30
数据结构实验报告2线性表的链式存储结构 本实验报告的主要内容是介绍线性表的链式存储结构，并通过编程实验来掌握线性表的逻辑结构和链式存储结构，以及单链表的基本算法。 一、线性表的概念 线性表是最基本的...
线性表-链式表示和实现
11-10
在计算机科学中，线性表的实现通常有两种方式：顺序存储和链式存储。本篇文档主要关注的是链式存储的实现，特别是在C++语言中的应用。 链式存储的线性表是由一系列节点组成，每个节点包含两部分：数据域和指针域。...
数据结构实验报告2线性表的链式存储结构.doc
07-11
实验报告的主题是“线性表的链式存储结构”，它主要涵盖了线性表的基本概念、链式存储方式以及相关的操作，如初始化、插入、删除、查找等。线性表是一种基本的数据结构，它是由n（n>=0）个相同类型元素构成的有限...
图解线性表的链式存储
吾竹清风2017
09-09 265
#ifndef _MYLINKLIST_H_ #define _MYLINKLIST_H_ //链表 typedef void LinkList; //链表节点 typedef struct _tag_LinkListNode { struct _tag_LinkListNode *next; }LinkListNode; LinkList* LinkList_Create(); void LinkList_Destroy(LinkList* list); ...
线性表的链接储存结构及实现
邵光亮的博客
09-22 1277
单链表 1 单链表的定义 单链表是用一组任意的存储单元来存放线性表的元素。存储单元可以连续，也可以不连续 为了正确的表示元素之间的逻辑关系，每个存储单元除了存储元素外 ，还需要存储后继元素的位置，这个地址信息用指针表示，称为指针；这两个元素组成了数据元素的存储映像，称为结点 也就是说节点有两个部分组成的 数据域 指针域 2 单链表结点c++实现 struct Node{ ...
线性表的链接存储结构及实现——单链表
qq_28840013的博客
12-21 1437
1.单链表的存储方法： 单链表是用一组任意的存储单元存放线性表的元素，这组存储单元可以连续也可以不连续。 为了表明元素之间的逻辑关系，每个元素需要存储自身数据（data）的同时，还必须存储其后继元素的地址信息，这个地址信息称为指针（next），这两部分（data和next）组成了每个数据元素的存储形式，称为结点。 用C++描述单个结点的结构： template&amp;amp;lt;class T&amp;amp;gt; str...
线性表的实现（链式存储）
shi_xiao_xuan的博客
10-30 549
线性表的实现1.结构体定义-链式2.表长3.查找（按序号）4.查找（按值）5.插入6.删除7.打印整表测试完整代码 1.结构体定义-链式 typedef struct LNode { ElementType Data; struct LNode* next; }*List; List PtrL; 或者 typedef struct LNode *List; struct LNode ...
链式存储结构线性表
晴。
12-01 446
链式存储结构线性表 顺序表的问题： 1、顺序表的访问和修改的时间复杂度是常数级的，非常快。但是顺序表的插入和删除的缺不好，这两种操作的时间复杂读是O(N)，看上去挺好，但是顺序表的插入和删除是通过大量数据的移动形成的。考虑最坏的情况，一个顺序表很长，在第一个位置插入元素，或者删除一个很长的顺序表的第一个元素，需要移动大量的元素，当元素的类型是复杂的类类型时，这种情况就更糟了。 2、顺序表
线性表 链式存储
weixin_60833644的博客
04-10 2808
线性表的链式存储（单向链（循环），双向链（循环））
数据结构与算法——线性表的链式储存结构
xzt12138的博客
07-23 2332
链式储存结构：n个结点链组成一个链表，即为线性表的链式存储结构。因为此链表的每个结点中只包含一个指针域，所以叫做单链表。我们把链表中第一个结点的存储位置叫做头指针。在单链表中第一个结点前附设一个结点，称为头结点。（头结点的数据域可以不储存任何信息）...
数据结构（四） — 线性表之链式存储
dashifu11111的博客
03-26 2997
一、线性表的链式存储结构 1、线性表链式存储结构定义 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。这就意味着，这些数据元素可以存在内存未被占用的任意位置。 以前在顺序结构中，每个数据元素只需要存数据元素信息就可以了。现在链式结构中，除了要存数据元素信息外， 还要存储它的后继元素的存储地址。 因此，为了...
线性表的顺序存储和链式存储差异
张洁的笔记
05-25 7547
线性表的顺序存储和链式存储方式在存读数据以及插入删除数据时，时间复杂度不同。顺序存储的典型例子为数组，链式存储的典型例子为单链表。众所周知，当读取数据较为频繁时，我们选择顺序存储方式，当插入和删除操作较为频繁时，我们选择链式存储方式。接下来，我们将分析这样做的原因：1.顺序存储：1）在读取数据时，读取任意位置i的元素，都可以用a[i]获得，因此，时间复杂度为o(1).2）在插入和删除数据时，不可能...
线性表的链式存储结构分析
链式存储结构是线性表的一种重要实现方式，具有其独特的优缺点。” 线性表的链式存储结构是通过一系列物理存储单元来表示线性表的数据元素，每个节点除了存储数据元素外，还包含指向下一个节点的指针。这种存储方式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值