【探索数据结构与算法（C语言）】——顺序表

已于 2024-08-07 09:31:24 修改
阅读量578 收藏 19
点赞数 29
分类专栏： 数据结构与算法（c语言） 文章标签： 数据结构
于 2024-08-06 23:01:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80220709/article/details/140967757
版权

💓 博客主页：C-SDN花园GGbond

⏩ 文章专栏：探索数据结构与算法

目录

1. 什么是顺序表

2. 顺序表的功能 

3. 顺序表的定义 

4. 功能的具体实现 

4.1 初始化顺序表

4.2 打印数据 

4.3 尾插数据 

4.4 尾删数据 

4.5 头删数据 

4.6 查找指定值

4.7 指定位置修改

4.8 指定位置插入  

4.9 指定位置删除

4.10 回收空间

5. 完整代码 

1. 什么是顺序表

顺序表是数据结构中最基本的一种线性表，它以一段连续的存储空间来存储数据元素，元素之间的顺序由它们在内存中的位置来决定。在C语言中，我们通常使用数组来实现顺序表 

2. 顺序表的功能 

顺序表可以大致包含以下几个功能：

1.初始化顺序表中的数据。

2.打印顺序表中的数据。

3.对顺序表进行尾插(末尾插入数据)。

4.对顺序表进行尾删(末尾删除数据)。

5.对顺序表进行头插(开头插入数据)。

6.对顺序表进行头删(开头删除数据)。

7.对顺序表就像查找数据。

8.对顺序表数据进行修改。

9.任意位置的删除和插入数据。

10.销毁顺序表。

3. 顺序表的定义 

定义顺序表我们首先需要一个动态内存开辟的空间，当前数据的个数(size)，以及方便扩容的容量大小(capacity)

typedef int SLDataType; //类型重命名，方便后续修改类型
#define N 4 //初始化空间大小
typedef struct SeqList
{
	SLDataType* a;    //指向动态开辟的数组
	size_t size;      //有效数据个数
	size_t capacity;  //容量大小
}SeqList;

4. 功能的具体实现 

4.1 初始化顺序表

初始化顺序表时我们可以先开辟四个空间，之后不够再进行扩容

void SeqListInit(SeqList* p)
{
	assert(p);  //断言
	p->a =(SLDataType*)malloc(N*sizeof(SLDataType));  //初始顺序表为四个空间
	if (p->a== NULL)
	{
		perror("malloc fail:");
                return ;
	}
	p->size = 0;  //初始数据个数为0
	p->capacity = 4;  //初始空间容量为4
}
4.2 打印数据 

打印数据只用循环打印就可以了。

void SeqListPrint(const SeqList* p)
{
	assert(p);  //断言
	if (p->size == 0)  //判断顺序表是否为空
	{
		printf("顺序表为空\n");
		return;
	}

	int i = 0;
	for (i = 0; i < p->size; i++)  //打印顺序表
	{
		printf("%d ", p->a[i]);
	}
	printf("\n");
}
4.3 尾插数据 

尾插数据，顾名思义就是在顺序表末尾插入数据，在插入数据之前我们应该检查顺序表是否为满。

 (1) 检查是否已满

void CheckCapacity(SeqList* p)
{
	assert(p);  //断言
	if (p->size == p->capacity)  //检查容量，满了则增容
	{
		size_t newcapacity = 2 * p->capacity;  //，扩容为原来的2倍
		SLDataType* prt = (SLDataType*)realloc(p->a, newcapacity * sizeof(SLDataType));  //扩容
		if (prt == NULL)
		{
			perror("realloc fail:");
			return ;
		}
		p->a = prt;  // prt不为空，开辟成功
		p->capacity = newcapacity;  //更新容量
	}
}

(2) 插入数据 

void SeqListPushBack(SeqList* p, SLDataType x)
{
	assert(p);  //断言
	CheckCapacity(p);  //检查顺序表容量是否已满
	p->a[p->size] = x;  //尾插数据
	p->size++;  //有效数据个数+1
}
4.4 尾删数据 

同理，尾删数据就是删除顺序表中最后一个元素，我们只需将size–。注意：删除之前要保证顺序表中有数据

代码实现 ：

void SeqListPopBack(SeqList* p)
{
	assert(p);  //断言
	assert(p->size > 0);  //顺序表不能为空
	p->size--;  //有效数据个数-1
}
4.5 头删数据 

 从头部删除数据，与尾部删除数据不同，需要依次往前覆盖。

代码实现： 

void SeqListPopFront(SeqList* p)
{
	assert(p);  //断言
	assert(p->size > 0);  //顺序表不能为空

	int i = 0;
	for (i = 1; i < p->size; i++)  //顺序表中[1,size-1]的元素依次向前挪动一位
	{
		p->a[i - 1] = p->a[i];
	}
	p->size--;  //有效数据个数-1
}
4.6 查找指定值

根据输入参数，在顺序表中查找指定的值并返回其下标，若未找到则返回-1。

代码实现： 

int SeqListFind(const SeqList* p, SLDataType x)
{
	assert(p);  //断言

	int i = 0;
	for (i = 0; i < p->size; i++)
	{
		if (p->a[i] == x)
		{
			return i;  //查找到，返回该值在数组中的下标
		}
	}
	return -1;  //没有查找到
}

4.7 指定位置修改

我们可以通过指定下标或者查找指定值的下标来修改任意位置的值。

代码实现 ：

void SeqListModify(SeqList* p, int pos, SLDataType x)
{
	assert(p);  //断言
	assert(p->size > 0);  //顺序表不能为空
	assert(pos >= 0 && pos < p->size);  //检查pos下标的合法性
	p->a[pos] = x;  //修改pos下标处对应的数据
}
4.8 指定位置插入  

和前面其他插入一样，指定位置插入也需要判断是否扩容。


 代码实现 ：

void SeqListInsert(SeqList* p, int pos, SLDataType x)
{
	assert(p);//断言
	assert(pos>=0&&pos <= p->size); //检查pos下标的合法性
	SeqListCheck(p);//检查是否需要扩容
	int cur = p->size;
	while (cur > pos)
	{
		p->a[cur] = p->a[cur - 1];//覆盖
		--cur;
	}
	p->a[pos] = x;
	p->size++;
}
4.9 指定位置删除

和前面的删除差不多，但是指定删除可能会依次覆盖

代码实现： 

void SeqListErase(SeqList* p, int pos)
{
	assert(p);  //断言
	assert(p->size > 0);  //顺序表不能为空
	assert(pos >= 0 && pos < p->size);  //检查pos下标的合法性
	int i = 0;
	for (i = pos + 1; i < p->size; i++)  //将pos位置后面的数据依次向前挪动一位
	{
		p->a[i - 1] = p->a[i];
	}
	p->size--;  //有效数据个数-1
}
4.10 回收空间

在结束操作之后，需要释放开辟的空间，以防止内存泄漏。

void SeqListDestory(SeqList* p)
{
	assert(p);  //断言
	free(p->a);   //释放动态开辟的空间
	p->a = NULL;  //置空
	p->size = 0;  //数据个数置0
	p->capacity = 0;  //空间容量大小置0
}

5. 完整代码 

 SeqList.h

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#define N 4 //初始化空间大小
typedef int SLDataType; //类型重命名，方便后续修改类型
typedef struct SeqList
{
	SLDataType* a;    //指向动态开辟的数组
	size_t size;      //有效数据个数
	size_t capacity;  //容量大小
}SeqList;

void SeqListInit(SeqList* p);//初始化顺序表
void SeqListPrint(const SeqList* p);//打印顺序表
void SeqListPushBack(SeqList* p, SLDataType x);//尾插
void SeqListPopBack(SeqList* p);//尾删
void SeqListPushFront(SeqList* p, SLDataType x);//头插
void SeqListPopFront(SeqList* p);//头删
int SeqListFind(const SeqList* p, SLDataType x);//查找数据
void SeqListModify(SeqList* p, int pos, SLDataType x);//修改数据
void SeqListInsert(SeqList* p, int pos, SLDataType x);//指定插入
void SeqListErase(SeqList* p, int pos);//指定删除
void SeqListDestory(SeqList* p);//释放空间

 SeqList.c 文件

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"
void SeqListInit(SeqList* p)
{
	assert(p);  //断言
	p->a =(SLDataType*)malloc(N*sizeof(SLDataType));  //初始顺序表为四个空间
	if (p->a == NULL)
	{
		perror("malloc fail:");
		return ;
	}
	p->size = 0;  //初始数据个数为0
	p->capacity = 4;  //初始空间容量为4
}
void CheckCapacity(SeqList* p)
{
	assert(p);  //断言

	if (p->size == p->capacity)  //检查容量，满了则增容
	{
		size_t newcapacity = 2 * p->capacity;  //，扩容为原来的2倍
		SLDataType* prt = (SLDataType*)realloc(p->a, newcapacity * sizeof(SLDataType));  //扩容
		if (prt == NULL)
		{
			perror("realloc");
			return ;
		}
		p->a = prt;  // prt不为空，开辟成功
		p->capacity = newcapacity;  //更新容量
	}
}
void SeqListPushBack(SeqList* p, SLDataType x)
{
	assert(p);  //断言
	CheckCapacity(p);  //检查顺序表容量是否已满
	p->a[p->size] = x;  //尾插数据
	p->size++;  //有效数据个数+1
}
void SeqListPrint(const SeqList* p)
{
	assert(p);  //断言
	if (p->size == 0)  //判断顺序表是否为空
	{
		printf("顺序表为空\n");
		return;
	}

	int i = 0;
	for (i = 0; i < p->size; i++)  //打印顺序表
	{
		printf("%d ", p->a[i]);
	}
	printf("\n");
}
void SeqListPopBack(SeqList* p)
{
	assert(p);  //断言
	assert(p->size > 0);  //顺序表不能为空
	p->size--;  //有效数据个数-1
}
void SeqListPushFront(SeqList* p, SLDataType x)
{
	assert(p);  //断言
	CheckCapacity(p);  //检查顺序表容量是否已满

	int i = 0;
	for (i = p->size - 1; i >= 0; i--)  //顺序表中[0,size-1]的元素依次向后挪动一位
	{
		p->a[i + 1] = p->a[i];
	}
	p->a[0] = x;  //头插数据
	p->size++;  //有效数据个数+1
}
void SeqListPopFront(SeqList* p)
{
	assert(p);  //断言
	assert(p->size > 0);  //顺序表不能为空

	int i = 0;
	for (i = 1; i < p->size; i++)  //顺序表中[1,size-1]的元素依次向前挪动一位
	{
		p->a[i - 1] = p->a[i];
	}
	p->size--;  //有效数据个数-1
}
int SeqListFind(const SeqList* p, SLDataType x)
{
	assert(p);  //断言

	int i = 0;
	for (i = 0; i < p->size; i++)
	{
		if (p->a[i] == x)
		{
			return i;  //查找到，返回该值在数组中的下标
		}
	}
	return -1;  //没有查找到
}
void SeqListModify(SeqList* p, int pos, SLDataType x)
{
	assert(p);  //断言
	assert(p->size > 0);  //顺序表不能为空
	assert(pos >= 0 && pos < p->size);  //检查pos下标的合法性
	p->a[pos] = x;  //修改pos下标处对应的数据
}
void SeqListInsert(SeqList* p, int pos, SLDataType x)
{
	assert(p);//断言
	assert(pos <= p->size); //检查pos下标的合法性
	SeqListCheck(p);//扩容
	int cur = p->size;
	while (cur > pos)
	{
		p->a[cur] = p->a[cur - 1];//覆盖
		--cur;
	}
	p->a[pos] = x;
	p->size++;
}
void SeqListErase(SeqList* p, int pos)
{
	assert(p);  //断言
	assert(p->size > 0);  //顺序表不能为空
	assert(pos >= 0 && pos < p->size);  //检查pos下标的合法性
	int i = 0;
	for (i = pos + 1; i < p->size; i++)  //将pos位置后面的数据依次向前挪动一位
	{
		p->a[i - 1] = p->a[i];
	}
	p->size--;  //有效数据个数-1
}
void SeqListDestory(SeqList* p)
{
	assert(p);  //断言
	free(p->a);   //释放动态开辟的空间
	p->a = NULL;  //置空
	p->size = 0;  //数据个数置0
	p->capacity = 0;  //空间容量大小置0
}


 

C-SDN花园GGbond
关注
专栏目录
数据结构与算法C语言版—— 数据结构的详细介绍
xiongIT的博客
02-26 5507
顺序存储结构、索引存储结构、哈希（散列）存储结构、链式存储结构的详细概述
数据结构与算法——顺序表 (完整代码)
zz137955的博客
10-31 1992
基于语言实现数据结构第一节——顺序表 增删查改
顺序表
lee__7的博客
09-23 253
链表五种形式： 单链表：数据域＋指针域（指向后继结点） 无论是否带头结点，头指针都指向第一个结点。 带头结点：链表为空： head-&amp;amp;amp;amp;amp;gt;next = NULL。第一个结点是头结点。head始终不为空 不带头结点：链表为空： head = NULL。第一个结点是开始结点 理解头结点：头结点是标志，值域不含信息，头结点后继结点存储信息 理解头指针：head 双链表 循环单链表：...
顺序表的详解
m0_57330725的博客
11-22 4206
线性表是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串.... 即顺序表为线性表的一种， 顺序表是一种物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数据上完成数据的增删查改。 顺序表一般分为 1.静态顺序表：使用定长数组存储元素 #defined N 7 typedef int SLDataType typedef struct SeqList { SLDataType* dat
探索数据结构：深入了解顺序表的奥秘
Bettysweetyaaa的博客
03-02 2257
顺序表是一种经典的数据结构，它以连续的存储空间存储元素，提供快速的随机访问能力。本文将深入探讨顺序表的原理、特点以及常见操作，帮助读者全面了解顺序表的内部机理和优劣势。无论您是初学者还是资深开发者，对于数据结构的理解都至关重要。通过本文的解读，相信您将对顺序表有更深入的认识，并能够更好地运用它来解决实际问题。
顺序表的介绍及应用
qq_35671247的博客
05-06 566
数据结构：线性表（java实现） 1.线性表 一个线性表（Linear List）是由n(n≥0)个数据元素（结点，它可以是一个字母，数字，记录或更复杂的信息）所构成的有限序列。线性表逻辑地表示为：（a0,a1,…,an-1)。其中，n为线性表的长度，n=0时为空表。称i为ai在线性表中的位序号。 然后，我们对顺序存储结构用图来做一个理解。 1.1 顺序存储结构理解 顺序储存结构是用数组来保存数据的。如下图： 说明：线性表也就是数组的一种特殊储存方式：从头到尾依次储存数据。 下面这种情况就不是线性表：
顺序表的定义和基本操作
youngurt的博客
05-03 4773
1、顺序表的定义 顺序表，即线性表的顺序存储，用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表中在逻辑结构上相邻的两个元素在物理位置上也相邻。 注意：线性表中元素的位序是从1开始的，而数组中元素的下标是从0开始的。 假定线性表的元素类型为ElemType，线性表的顺序存储可以是静态的，也可以是动态的。 //静态分配 #define maxSize 100; //定义顺序表的最大长度 typedef struct{ Elemtype data[maxSize]; //顺序表的元
C语言中的数据结构和算法分析：C ++实现《数据结构与算法分享——C语言描述》
02-05
本文将基于C语言，结合C++实现，深入探讨数据结构与算法，为开发者提供宝贵的理论知识与实践经验。 数据结构是组织和管理数据的方式，它为数据提供了高效的访问和操作手段。常见的数据结构包括数组、链表、栈、队列...
数据结构与算法基础课程 C语言C++程序语言设计教程 2_2线性表-顺序表 共12页.pptx
最新发布
07-20
本课程旨在为初学者提供一个全面的数据结构与算法基础学习框架，重点介绍在计算机科学领域中非常重要的数据结构——线性表，并具体分析其中的顺序表实现。通过本课程的学习，学生将能够理解线性表的基本概念、顺序表...
顺序表的操作，你真的学会了吗？
princekin
04-21 5885
编程实现顺序表的以下基本操作：建立顺序表，修改顺序表，插入顺序表，删除顺序表。
顺序表详解
Yzl17841857589的博客
03-27 797
检查完后就可以开始移动了，和头插差不多，我们创建一个变量 end 记录最后一个的下标（psl->size-1），并通过它来指向要移动的数据。移动完后，x 的位置就腾出来了，再把 x 插入进去，最后再 size++，就完成了。思路：首先创建一个 end 变量用来指向要移动的数据，因为指向的是数据的下标，所以是 size 要减 1。这里有可能会出现如果内存中一个元素都没有了，size有可能减到-1的位置上，这便是越界了，但size是我们用来统计元素数量的，不可能小于0的，所以这里我们需要断言一下。
顺序表的总结
weixin_42373873的博客
04-21 1934
顺序表： 线性表的顺序存储是用一组连续的内存单元依次存放线性表的数据元素，元素在内存的物理存储次序与它们在线性表中的逻辑次序相同 顺序表的一些基本操作： 插入：在顺序表元素ai位置插入元素x,首先必须将元素ai,a(i+1),…,a(n-1)向后移动，空出一个位置，然后将x插入。 删除：删除顺序表ai，必须将元素a(i+1),a(i+2),…,a(n-1)向前移动。原来第i个位置变为a(i+1...
数据结构（一）——顺序表（C语言实现）
flueky的专栏
09-30 5万+
顺序表的简单实现
数据结构：顺序表的基本操作
热门推荐
Keep Fighting All The Time
05-03 10万+
线性表的顺序存储 顺序表的线性存储示意图 C语言定义线性表的顺序存储结构 线性表的顺序存储        线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中，即：通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。采用顺序存储结构存储的线性表通常简称为顺序表。        顺序存
顺序表——基本概念、顺序表类实现、基本操作
Theo's Mind Palace
10-22 5713
顺序表 线性表的顺序存储结构 1、数组是实现顺序存储结构的基础。 特点：地址连续确定，容量固定，随机存取T(n) = O(1) 一维数组占用一块内存空间，数组的存储单元个数成为数组容量，也成为数字长度。每个存储单元的地址是连续的，即每个元素连续存储。（反映了顺序表的逻辑结构）。 存取任何一个元素的时间复杂度是O(1)的数据结构成为随机存储结构，数组也是随机存储结构。 2、顺序表
顺序表的类型定义以及基本操作函数
qq_38846633的博客
07-22 1万+
引言 本篇文章是我的处女作，主要是我学习清华大学出版社《数据结构》课程顺序表一节的心得体会，主要内容为对于书本上伪代码的详细实现的补充以及学习，如果有任何错误或可以改进之处欢迎各位巨巨指出 正文 顺序表作为线性结构的一种，而线性结构的特点是：1.存在唯一的一个被称为“第一个”的元素，同时也存在唯一的一个被称为“最后一个”的元素 2、集合之中的每一个元素均有且仅有一个它的前驱或后...
顺序表的理解与使用
HyHarden的博客
08-13 2625
一、前言 顺序表是线性表（链式表和顺序表）的一种，线性表是线性排列的一组具有相同数据类型的元素的有限集合，除第一个元素外，所有的元素都有且只有一个直接后驱。除最后一个元素外，所有的元素都有且只有一个直接前驱。它是数据结构中最常用也是最基本最简单的数据结构，它的基本操作有检索元素，插入元素，删除元素.......接下来会解析顺序表的概念和使用（含c,c++,java三种语言实现）。
深入浅出数据结构与算法分析——以C语言视角
"这是一本关于数据结构与算法分析的专业书籍，使用C语言进行阐述，由国外作者Robert Lafore撰写，英文版。虽然标题提到C语言，但部分内容提及该书也有Java版本，同样适合对数据结构和算法有一定基础的读者。书中通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值