（数据结构）顺序表和链表

已于 2022-08-07 12:30:59 修改
阅读量566 收藏 9
点赞数 6
分类专栏： 数据结构初阶 文章标签： 链表 数据结构 c语言
于 2022-08-07 12:25:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Captain_ldx/article/details/126208274
版权

今天船长计划用简单的方式向大家介绍数据结构中重要知识点——顺序表和链表

全文干货，强烈建议先赞后看哦！话不多说，让我们马上开始今天的学习之旅吧！

目录

1.线性表

2.顺序表

2.1顺序表的概念

2.2动态顺序表的接口实现

2.2.1头文件的包含

2.2.2构造顺序表结构

2.2.3构造接口

2.2.4初始化、删除顺序表

2.2.5检查容量、输出（函数）

2.2.6尾插、尾删、头插、头删

2.2.7从某个位置插入或删除

2.2.8查找、修改 

3.链表

3.1链表的概念

3.2链表的结构

3.3链表的分类

3.4无头单向链表的接口实现

3.4.1头文件包含

3.4.2构造链表结构体

3.4.3构造链表接口

3.4.4输出、创建新结点

3.4.5尾插、尾删、头插、头删

3.4.6查找

3.4.7在pos之前（之后）插入、删除pos位置的值

4.结语

1.线性表

线性表（linear list）是n个具有相同特性的数据元素组成的有限序列；

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续，
线性表在物理上存储时，通常以数组和链式结构的形式存储；

线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...

2.顺序表

2.1顺序表的概念

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存
储。在数组上完成数据的增删查改。

顺序表一般可以分为：

  • 静态顺序表
  • 动态顺序表

静态顺序表需要自行指定数组的大小，而动态顺序表具有可以按需分配空间，所以接下来我主要介绍动态顺序表的接口实现

2.2动态顺序表的接口实现

2.2.1头文件的包含

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

2.2.2构造顺序表结构

typedef struct seqlist
{
	SLDataType* a;//指向动态数组的指针
	int size;	  //数据个数
	int capacity; //内存空间大小，容量
}SL;

2.2.3构造接口

//初始化
void seqlistinit(SL* ps);//初始化,要加分号；
//删除
void SLDestory(SL* ps);
//检查容量
void SLCheckCapacity(SL* ps);
//输出
void SLPrint(SL* ps);

//尾插、尾删、头插、头删
void SLPushBack(SL* ps, SLDataType x);
void SLPopBack(SL* ps);
void SLPushFront(SL* ps, SLDataType x);
void SLPopFront(SL* ps);

//某个位置插入
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);

//查找
int SLFine(SL* ps, SLDataType x);
//修改
void SLModifty(SL* ps, int pos, SLDataType x);

2.2.4初始化、删除顺序表

void seqlistinit(SL* ps)//初始化+s(第一种),改为指针为了初始化结构体中的参数
{
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}


void SLDestory(SL* ps)//删除顺序表
{
		free(ps->a);//检查指针问题
		ps->a = NULL;
		ps->capacity = ps->size = 0;
}

2.2.5检查容量、输出（函数）

void SLCheckCapacity(SL* ps)
{
	//检查容量空间,满了就要扩容
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		//size_t size这里要输入的是新空间的大小（字节）
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));//realloc默认返回void*
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			//return;
			exit(-1);//退出
		}

		ps->a = tmp;//将新的拥有空间的指针给ps->a
		ps->capacity = newcapacity;
	}
}
//输出
void SLPrint(SL* ps)
{
	assert(ps != NULL);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d", ps->a[i]);
		printf("\n");
	}
}

2.2.6尾插、尾删、头插、头删

//尾插
void SLPushBack(SL* ps, SLDataType x)
{
	SLCheckCapacity(ps);//这里传指针ps，不要SL*ps

	ps->a[ps->size] = x;//把x插入顺序表尾部
	ps->size++;//数据个数++
}
//尾删
void SLPopBack(SL* ps)
{
	//暴力检查，可以直接查验错误
	assert(ps->size > 0);//可能size<0会越界

	ps->size--;
}
//头插 
void SLPushFront(SL* ps, SLDataType x)
{
	SLCheckCapacity(ps);

	int end = ps->size - 1;
	//挪动数据
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}

	ps->a[0] = x;
	ps->size++;
}

//头删
void SLPopFront(SL* ps)
{
	assert(ps->size > 0);
	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin-1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}

2.2.7从某个位置插入或删除

//某个位置(pos)插入
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	SLCheckCapacity(ps);

	int end = ps->size - 1;
	while (end >= pos)//重叠的时候终止
	{
		ps->a[end + 1] = ps->a[end];
		end--;//移动end
	}
	ps->a[pos] = x;
	ps->size++;
}
//删除pos位置的数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	int begin = pos;
	while (begin < ps->size - 1)//避免往后越界,因为这里有begin+1
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}

2.2.8查找、修改 

//查找是否有x
int SLFine(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
		return -1;//没有找到
	}

}
//修改pos位置数据
void SLModifty(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	ps->a[pos] = x;
}

3.链表

3.1链表的概念

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表
中的指针链接次序实现的 ；

3.2链表的结构

如下图所示

由链表的性质我们可以得知

  1. 链表结构的逻辑是连续的，但是物理存储结构不一定连续 ；
  2. 现实中链表的结点都是在堆中申请出来的；
  3. 堆上申请的空间是按照一定策略分配的，申请两次的空间可能连续，也可能不连续；

3.3链表的分类

详细的链表分类见：（数据结构）带头双向循环列表的实现 - 2

3.4无头单向链表的接口实现

3.4.1头文件包含

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

3.4.2构造链表结构体

typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

3.4.3构造链表接口

//输出
void SListPrint(SLTNode* phead);
//创建新结点
SLTNode* buySlistNode(SLTDataType x);

//尾插
void SListPushBack(SLTNode** pphead, SLTDataType x);
//头插
void SListPushFront(SLTNode** pphead, SLTDataType x);
//尾删
void SListPopBack(SLTNode** pphead);
//头删
void SListPopFront(SLTNode** pphead);

//查找
SLTNode* SListFind(SLTNode* phead, SLTDataType x);

// 在pos位置之前（之后）插入
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
// 删除pos位置的值
void SListErase(SLTNode** pphead, SLTNode* pos);

3.4.4输出、创建新结点

//输出
void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;//指向本结点的下一个结点的地址
	}
	printf("NULL\n");
}
//创建新结点
SLTNode* buySlistNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//设立一个新的结点
	assert(newnode);
	newnode->data = x;
	newnode->next = NULL;

	return newnode;//返回新指针
}

3.4.5尾插、尾删、头插、头删

//尾插
//要改变int* 要传int*的地址 用int**接收
void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = buySlistNode(x);

	if (*pphead == NULL)//phead为空指针
	{
		*pphead = newnode;
	}
	else
	{
		//找尾结点
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
}
//尾删
void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);//断言

	if ((*pphead)->next == NULL)//这里要注意(*pphead),验证是否只有一个节点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}
//头插
void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = buySlistNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
//头删
void SListPopFront(SLTNode** pphead)
{
	assert(*pphead);
	SLTNode* next = (*pphead)->next;//要先让指针指向next，再释放空间
	free(*pphead);
	*pphead = next;
}

 3.4.6查找

//查找
SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)//空指针为0，判定为假
	{
		if (cur->data == x)
			return cur;//返回指针，在测试时仍要写额外的语句

		cur = cur->next;
	}

	return NULL;
}

3.4.7在pos之前（之后）插入、删除pos位置的值

//在pos之前插入
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)//传头部地址、pos位置
{
	assert(pos);
	assert(pphead);

	// 头插
	if (pos == *pphead)
	{
		SListPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		SLTNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}
// 单链表在pos位置之后插入x
void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	/*SLTNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;*/

	// 不在乎链接顺序 - 下列方法（用next指针指向pos->next,防止丢失）
	SLTNode* newnode = BuySListNode(x);
	SLTNode* next = pos->next;
	// pos newnode next
	pos->next = newnode;
	newnode->next = next;
}
// 删除pos位置的值
void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		prev->next = pos->next;

		free(pos);
		pos = NULL;
	}
}

4.结语

看到这里，相信老铁们对顺序表和链表的知识已经有了相应的了解。 

我是计算机海洋的新进船长Captain_ldx,如果我的文章能对您有帮助的话，麻烦各位观众姥爷们点赞、收藏、关注，你们的每一次举手之劳都将化为船长的前进动力！

Captain-Lin
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
顺序表与链表
m0_56931704的博客
09-06 1414
顺序表与链表 一.顺序表 1.定义：将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构。采用顺序存储结构的线性表简称为“ 顺序表”。 顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中 顺序表可以分为静态顺序表和动态顺序表 2.结构定义： #define MAXSIZE 100 typedef int ElemType; typedef struct Seqlist {//静态顺序表 ElemType data[MAXSIZE]; size_t size
数据结构实验 顺序表和链表
最新发布
10-08
数据结构实验 顺序表和链表中，我们可以学习到顺序表和链表的基本操作，包括创建、初始化、销毁、求长、判空、输出、获取元素、插入元素和删除元素等操作。下面是对顺序表和链表的详细介绍： 顺序表是一种线性表，...
【数据结构】顺序表和链表详解
m0_62934529的博客
04-28 3382
1. 线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 2. 顺序表 2.1 概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。顺序表的物理结构和逻辑结构是
数据结构-顺序表与链表详解
m0_62918577的博客
11-05 1626
顺序表概念及分类，以及动态顺序表的接口实现 链表的概念及结构以及无头单向非循环链表的接口实现 在不同方面解析顺序表和链表的区别
顺序表和链表
huajiahhhh的博客
07-30 79
一.顺序表二.链表。
数据结构顺序表和链表的相关操作
06-30
1.依次从键盘读入数据，建立顺序表和链表；2.求顺序表的长度；3.根据指定条件能获取元素；4.实现在指定位置插入和删除元素的功能 主菜单设计要求： 程序运行后创建顺序表和链表，之后给出9个菜单项的内容和输入提示...
数据结构顺序表和链表（超详细）
08-14
创建返回链表的头结点.// 双向链表销毁// 双向链表打印// 双向链表尾插// 双向链表尾删// 双向链表头插// 双向链表头删// 双向链表查找// 双向链表在pos的前面进行插入// 双向链表删除pos位置的结点
数据结构顺序表、链表和数组是逻辑结构还是物理（存储）结构？ 数组和链表.pdf
04-18
数据结构顺序表、链表和数组是逻辑结构还是物理（存储）结构？ 数据结构是计算机科学中的一门重要学科，它研究的是计算机中数据的组织、存储和处理方式。数据结构可以分为逻辑结构和物理结构两种。 逻辑结构是指...
数据结构试验1-链表和顺序表
03-08
数据结构链表和顺序表实验源码，没有实验报告，需要下载。
顺序表和链表的区别
garliccc的博客
09-23 3085
顺序表和链表的区别 首先了解顺序表和链表的概念 1.顺序表 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。 线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 特点: （1）在顺序表中，各个表项的逻辑顺序与其存储的物理顺序一致，即第 i 个表项存储于第 i 个物理位置（1 < i < n） （2）对顺序表中的所有表项，即可以进行顺序的访问，也可以随机的访问，也就是说，既可以从表
《数据结构》顺序表与链表
1
10-08 4727
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。}
顺序表and链式表
avvvbhhh的博客
09-05 177
复习
顺序表&链表超全大总结
yue152152的博客
03-29 1751
线性表 线性表是n个具有形同特性的数据元素的有限序列。常见的线性表：顺序表、链表、栈，队列、字符串……本文重点讲解顺序表和链表，其他结构可见数据结构专栏的其他内容 注意：线性表在逻辑上是线性结构，也就是说是连续的但在物理结构上。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。 顺序表 概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可分为静态顺序表和动态顺序表
顺序表和链表的比较和区别
热门推荐
每天学习一点点，成长一小步
04-03 1万+
一．顺序表和链表的比较1）顺序表：顺序表的特点是逻辑上相邻的数据元素，物理存储位置也相邻，并且顺序表的存储空间需要预先分配。 它的优点是： a) 方法简单，各种高级语言中都有数组，容易实现。 b) 不用为表示节点间的逻辑关系而增加额外的存储开销。 c) 顺序表具有按元素序号随机访问的特点。 缺点： a) 在顺序表中做插入、删除操作时，平均移动表中的一半元素，因此n较大的顺序表效率
数据结构之顺序表和链表
weixin_44456232的博客
08-11 314
1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。 2. 顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 静态顺序表：使用定长数组存储。 动
数据结构---顺序表和链表
04-20 236
1.线性表 线性表是具有n个相同特性的数据元素的有限序列，线性表在逻辑上是线性结构，在物理存储上通常以数组和链式结构的形式存储。 2.顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。 用数组实现ArrayList(顺序表) public class MyArrayList implements IArrayList { private int...
数据结构：链表与顺序表的优缺点
Fortuna_的博客
07-09 2547
1.顺序表存储     原理：顺序表存储是将数据元素放到一块连续的内存存储空间，存取效率高，速度快。但是不可以动态增加长度     优点：存取速度高效，通过下标来直接存储     缺点：1.插入和删除比较慢，2.不可以增长长度                    比如：插入或者删除一个元素时，整个表需要遍历移动元素来重新排一次顺序：     适用场景：频繁查询但很少用到插入与删除可以考虑顺序表2...
数据结构顺序表和链表
09-06
数据结构中，顺序表和链表是两种不同的存储结构。 顺序表是一种线性结构，它通过一段物理地址连续的存储单元来存储数据元素，并且采用数组的形式进行存储。顺序表在数组上完成数据的增删查改操作，同时记录表的长度和容量。可以通过下标来访问顺序表中的元素，具有随机访问的特点。顺序表的优点是可以快速访问任意位置的元素，但插入和删除元素时需要移动其他元素，时间复杂度为O(n)。 链表是一种非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表分为单向或双向、带头或不带头、循环或非循环等几种类型。常用的链表结构有无头单向非循环链表和带头双向循环链表。链表的优点是插入和删除元素时只需要修改指针的指向，时间复杂度为O(1)，但访问链表的某个元素需要从头开始遍历，时间复杂度为O(n)。 因此，顺序表适用于频繁访问元素的场景，而链表适用于频繁插入和删除元素的场景。<span class="em">1</span><span class="em">2</span><span class="em">3</span><span class="em">4</span>

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值