顺序表讲解 及 源代码

最新推荐文章于 2024-08-18 17:01:18 发布
最新推荐文章于 2024-08-18 17:01:18 发布
阅读量1.7k 收藏 21
点赞数 58
文章标签： 算法 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79903399/article/details/137354830
版权

为什么我们要使用顺序表：

我们先来看两张图：

    

想像如果在一篇草场上放我们自己的羊，当我们某天想要找一只叫肖恩的羊拿来做烤串，但是在草场上羊是杂乱无序的，我们想要找到一个特定的羊是非常困难的。而当我们像图二一样集中起来排好序，让每个羊都有自己的位置顺序排列，给肖恩标记号，这样当我们想要去找这只羊的时候只需要到它的编号的羊圈里找就可以很快的找到。

内存也是如此类似的，我们知道数组在内存中是连续的，而顺序表的底层就是数组这样我们就可以用这种特性使我们的程序效率大大提高。

如何创建一个顺序表：

顺序表的基本功能有增删查改，在VS中我们先创建一个.h文件用来存放头文件和函数的声明，一个SeqList.c用来实现增删查改等内容，一个test.c文件用来测试我们写的函数。

这样我们就将我们就在这三个项目中实现我们的顺序表。

静态顺序表：

#define N 100
struct SeqList
{
	int arr[N];
	int size;//有效数据个数
};

静态顺序表的大小为我们自己指定的，但这种方式的缺陷就是不能灵活的调整大小，给少了不够用，给多了用不完。因此在正常情况下，我们使用动态顺序表。

动态顺序表：

定义：
typedef int SLDataType;//方便后续类型的替换
typedef struct SeqList
{
	SLDataType* arr;
	int size;//有效的数据个数
	int capacity;//空间大小
}SL;
//也可以用typedef struct SeqList SL;
初始化：

我们把初始化函数声明为：

void SLInit(SL*ps);

接下来我们把里面的内容初始化

void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}
判断空间并扩容：

初始化好了之后我们就可以进行增删查改的操作，但我们最开是没有给顺序表空间，因此我们在增加的时候每一次都需要判断顺序表是否有足够的空间给我们使用。因此我们把判断是否有空间和自动增加空间的功能封装成一个函数，在一个每次增加元素的时候调用这个函数即可。

我们将判断空间的函数声明为

void SLCheckcapacity(SL* ps)
{
	if (ps->capacity == ps->size)
	{
		//申请空间
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newcapacity *sizeof(SLDataType));
        //申请多大空间
		if (tmp == NULL)
		{
			//空间申请失败
			perror("realloc fail!");
			exit(1);
		}
		//空间申请成功
		ps->arr= tmp;
		ps->capacity = newcapacity;
	}
}

这段代码中使用newcapacity来决定要扩容多大的空间（如果原空间为0我们给四个字节，如果原本有空间我们就扩大两倍。同时定义一个临时指针来接受扩容的空间（为了防止扩容失败后，还把我们原本空间中的数据释放）。

尾插：

如图我们知道size指向的位置就是我们要进行尾插的位置，我们只需要在size的位置插入后让size++就可以。

void SLPushBack(SL* ps,SLDataType x)
{
	assert(ps);//等价于if(ps!=NULL)
	SLCheckcapacity(ps);//插入之前检查空间够不够
	ps->arr[ps->size++] = x;
}

ps是我们的顺序表的指针，x是我们要尾插的元素。

头插：

头插就是在size=0的位置插入一个元素，如下图，我们把size前面的数据使用for循环每个都向后移动一位让最后一个元素到size的位置，size++，再在0的位置插入我们要插入的元素即可。

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckcapacity(ps);//插入之前检查空间够不够
	//让已有的数据往后移
	for (int i = ps->size;i>0; i--)
	{
		ps->arr[i] = ps->arr[i-1];//arr[1]=arr[0]
	}
	ps->arr[0] = x;
	ps->size++;
}
 尾删：

因为顺序表内容访问是size之前的数据，在尾删中如果我们让size--让size向前移动一个位置就可以实现，而减少的那个内容我们不需要去覆盖什么值，因为我们不会访问它，并且我们进行更改增加等操作时会有新值覆盖它，对这些操作都不会有任何影响。

void SLPopBack(SL* ps)
{
	assert(ps);
	//顺序表是否为空
	assert(ps->size);
	--ps->size;
}
头删：

如下图，头删就是删除第一个元素，那么我们让第一个元素后面的元素向前移动一个，那么第二个元素覆盖第一个依次类推就可以实现头删。因为数据少了一个size--。

void SLPopFront(SL* ps)

{
	assert(ps);
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
指定位置插入：

如上图我们在下标为2的位置插入数据时我们只需要让下标为2以及后面的元素向后移动一位，同时size++就可以腾出下标2的空间来插入数据。

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);//必须在顺序表数据范围内
	//插入数据：空间够不够
	SLCheckcapacity(ps);
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps -> arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}
指定位置删除：

与头删思路一样，我们只需要让删除的元素的位置后面的元素向前移动一位后，size--即可。

void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps -> arr[i + 1];
	}
	ps->size--;
}

查找：

查找的方式其实就是用遍历来找到与我们要找的元素一样的位置

int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

那么我们的增删查改的功能就差不多了。

我们可以通过调试或者是写一个打印代码来测试


打印代码：
void SLPrint(SL s)
{
	for (int i = 0; i < s.size; i++)
	{
		printf("%d  ", s.arr[i]);
	}
	printf("\n");
}
顺序表的销毁:

别忘了我们用完之后置空把内存要还回去哦

void SLDestroy(SL* ps)
{
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

测试一下：

源代码：

SeqList.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//
//静态顺序表
//#define N 100
//struct SeqList
//{
//	int arr[N];
//	int size;//有效数据个数
//};

//动态顺序表
typedef int SLDataType;//方便后续类型的替换
typedef struct SeqList
{
	SLDataType* arr;
	int size;//有效的数据个数
	int capacity;//空间大小
}SL;
//typedef struct SeqList SL;

//顺序表初始化
void SLInit(SL*ps);

//顺序表的销毁
void SLDestroy(SL* ps);

//头部插入删除
void SLPushBack(SL* ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x);

//尾部插入删除
void SLPopBack(SL* ps);
void SLPopFront(SL* ps);

//指定位置插入删除
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);

//顺序表的查找
int SLFind(SL* ps, SLDataType x);

//顺序表的打印
void SLPrint(SL s);

SeqList.c

#include "SeqList.h"
//================================================
//                 顺序表的初始化
//================================================
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}
//================================================
//                 判断空间够不够               //
// ===============================================
void SLCheckcapacity(SL* ps)
{
	if (ps->capacity == ps->size)
	{
		//申请空间
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newcapacity * sizeof(SLDataType));//申请多大空间
		if (tmp == NULL)
		{
			//空间申请失败
			perror("realloc fail!");
			exit(1);
		}
		//空间申请成功
		ps->arr= tmp;
		ps->capacity = newcapacity;
	}
}
//================================================
//                顺序表的尾插                  //
// ===============================================
void SLPushBack(SL* ps,SLDataType x)
{
	assert(ps);//等价于if(ps!=NULL)
	//插入之前检查空间够不够
	SLCheckcapacity(ps);
	ps->arr[ps->size++] = x;//++ps->size;
}
//================================================
//                 顺序表的头插                 //
//================================================
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	//插入之前检查空间够不够
	SLCheckcapacity(ps);
	//让已有的数据往后移
	for (int i = ps->size;i>0; i--)
	{
		ps->arr[i] = ps->arr[i-1];//arr[1]=arr[0]
	}
	ps->arr[0] = x;
	ps->size++;
}
//==================================================
//                  顺序表的尾删                  //
//==================================================
void SLPopBack(SL* ps)
{
	assert(ps);
	//顺序表是否为空
	assert(ps->size);
	--ps->size;
}
//================================================
//                  顺序表的头删                //
// ===============================================
void SLPopFront(SL* ps)

{
	assert(ps);
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
//================================================
//                 指定位置插入                 //
//================================================
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	//插入数据：空间够不够
	SLCheckcapacity(ps);
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps -> arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}
//================================================
//                 指定位置删除                 //
//================================================
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps -> arr[i + 1];
	}
	ps->size--;
}
//================================================
//                 顺序表的打印                 //
//================================================
void SLPrint(SL s)
{
	for (int i = 0; i < s.size; i++)
	{
		printf("%d  ", s.arr[i]);
	}
	printf("\n");
}
//================================================
//                 顺序表的查找                 //
//================================================
int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}
//================================================
//                 顺序表的销毁                 //
//================================================
void SLDestroy(SL* ps)
{
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}
//================================================

test.c

#include "SeqList.h"

void SLTest01()
{
	SL sl;
	SLInit(&sl);
	//增删查改
	//测试尾插
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushFront(&sl, 0);
	SLPushFront(&sl, -1);
	SLPushFront(&sl, -2);
	SLPushFront(&sl, -3);
	printf("原本的顺序表sl是\n");
	SLPrint(sl);
	printf("尾删后的的顺序表sl是\n");
	SLPopBack(&sl);
	SLPrint(sl);
	printf("头删后的顺序表sl是\n");
	SLPopFront(&sl);
	SLPrint(sl);
	SLDestroy(&sl);
}

void SLTest02()
{
	SL sq;
	SLInit(&sq);
	SLPushBack(&sq, 1);
	SLPushBack(&sq, 2);
	SLPushBack(&sq, 3);
	SLPushBack(&sq, 4);
	printf("原本的顺序表sq是\n");
	SLPrint(sq);
	printf("指定下标位置3插入0后的顺序表sq是\n");
	SLInsert(&sq, 3, 0);
	SLPrint(sq);
	printf("指定下标位置2删除后的顺序表sq是\n");
	SLErase(&sq, 2);
	SLPrint(sq);
	printf("寻找数字2\n");
	int find = SLFind(&sq, 2);
	if (find < 0)
	{
		printf("没有找到\n");
	}
	else printf("找到了，下标位置%d\n",find);
	SLDestroy(&sq);
}

int main()
{
	SLTest01();
	SLTest02();
	return 0;
}

请来次降维打击！！！
关注
  • 58
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
图书管理系统源代码＜Java＞（带文字讲解）(javase)
m0_52789121的博客
06-21 8979
很多同学在学校学习完Java后，就要开始做一个管理系统来通过课设考核，今天我就来交大家来实现一个图书管理系统。1.类和对象；（类是对象的实例化引用） 2.接口； 3.封装和继承； 4.顺序链表存储数据； 三，定义图书，操作，用户类 1.图书类book 1. 我们先在idea中创建一个文件夹命名为图书管理系统，打开文件夹，点击src 新建一个Package ，并命名为book 2. 点击book包，新建一个javaclass文件，命名为book；在点击book包新建一个javaclass文件，命名为BookL
基于线性表的图书管理系统 源代码 顺序表&链表
05-31
《基于线性表的图书管理系统》是一个典型的C语言实现的数据结构应用案例，它结合了顺序表和链表这两种基本的线性数据结构。这个系统旨在模拟图书馆中的图书管理操作，如添加、删除、查找和显示图书信息。在这个系统...
java设计一个顺序表类的成员函数_顺序表代码讲解以及实现
weixin_42405592的博客
02-26 818
用C语言编写一个有关顺序表的程序代码创建一个顺序表，其数据元素类型为整型；在该顺序表中插入数据(#include #include #define MaxSize 50 typedef char ElemType; typedef struct { ElemType elem[MaxSize]; int length; }SqList; void InitList(SqList *L) /* 初始...
顺序表插入操作的详细解释（代码版）
weixin_53256725的博客
11-20 5697
1 首先，我们要定义顺序表的结构体 #define MaxSize 10 //定义最大长度 typedef struct { int data[MaxSize]; //用静态数组存放数据元素 int length; //顺序表的当前长度 }SqList; //顺序表的类型定义 也就是这个表的名称 相当与String 这里结构体由一个数组(用来记录表中个数)和一个int型的length（记录顺序表的中的个数）组成，相当于先搭建一个框架 2初始化顺序表
数据结构之顺序表的增删查改等操作详解
小赵小赵福星高照的博客
08-03 2130
顺序表的增删查改 文章目录顺序表的增删查改顺序表静态顺序表：使用定长数组存储元素动态顺序表：使用动态开辟的数组存储顺序表的初始化顺序表的销毁打印顺序表数据顺序表尾插数据顺序表头插数据顺序表头删数据顺序表指定位置插入元素指定位置元素删除返回顺序表总数据的个数修改数据三个文件的源代码：SeqList.h(头文件的包含以及顺序表结构以及函数的声明)SeqList.c(顺序表操作函数的定义)test.c(顺序表操作的测试) 顺序表 一段物理地址连续的存储单元依次存储数据元素的线性结构，其实就是数组，要求存储的数
【数据结构】线性表之顺序表详解
@情话
10-28 1713
数据的逻辑结构分为线性结构和非线性结构，线性结构中的线性表根据存储结构又分为顺序表和链表。这篇博客主要讲的是顺序表的定义和基本操作，以及它是如何实现的。线性表是具有相同数据类型的n (n>=0)个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
如何阅读一份源代码？
涛思数据
04-09 5639
作者：codedump，本文已经作者授权。 导语：TDengine是一款优秀的开源物联网大数据平台，肯定很多工程师也想仔细研读一下项目代码，深入了解其优异的性能是如何做到的。从今天开始，我们将推出一系列文章，近距离研读TDengine的代码。希望能给大家阅读代码有一个整体上的指导。 阅读源代码的能力算是程序员的一种底层基础能力之一，这个能力之所以重要，原因在于： 不可避免的需要阅读或者接手他人的项目。比如调研一个开源项目，比如接手一个其他人的项目。 阅读优秀的项目源码是学习他人优秀经验的重要途径之一
数据结构 顺序表（c++实现）
u012350104的专栏
09-27 4757
实现了顺序表的基本操作 代码均为原创，转载请注明源地址blog.csdn.net/u012350104 欢迎留言交流 实现的功能： =====开始===== ==增加（1）== ==删除（2）== ==修改（3）== ==查询（4）== ==退出（0）== ============ ==============增加============== ==输
图解线性表顺序存储结构（附完整代码）
weixin_66831846的博客
12-18 2407
顺序表的增删查改
【数据结构与算法】顺序表增删查改的实现（动态版本+文件操作）附源码
旋律 | 话语 | 色彩 | 情景
02-23 3100
数据结构初阶：顺序表增删查改的实现（动态版本+文件操作）
数据结构教程ppt和源代码
12-21
这份“数据结构教程ppt和源代码”资料包为学习者提供了全面的学习资源，包括理论讲解和实践操作，对于深入理解和掌握数据结构至关重要。 首先，我们来看“数据结构教程第五版 PPT”。PPT文件通常包含精心设计的幻灯...
实验1 顺序表（参考代码）.rar
03-28
下面，我将详细讲解顺序表的基本概念、操作及其实现。 顺序表是由一组相同类型的数据元素构成的线性集合，这些元素在内存中是连续存放的。这种数据结构允许我们通过索引来直接访问任意位置的元素，索引通常是从0...
李春葆版数据结构源代码
04-23
《李春葆版数据结构源代码》是一份珍贵的学习资源，专门为那些想要深入理解数据结构并熟练掌握C语言编程的人员准备。李春葆教授是中国计算机科学领域知名的专家，他的《数据结构》教材以其深入浅出的讲解和丰富的...
殷人昆《数据结构》电子源代码
12-04
殷人昆老师的《数据结构》教材以其深入浅出的讲解和丰富的实例深受广大读者喜爱，而这里的压缩包文件包含了该教材第二版的类库源代码，经东南大学吴乃陵老师修订，为学习者提供了宝贵的实践材料。 数据结构通常涉及...
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 332
基于Pygame和PIL的迷宫生成器
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 780
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 550
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
noip2001数的划分
最新发布
no_play_no_games的博客
08-18 189
将整数n分成k份，且每份不能为空，任意两份不能相同(不考虑顺序)。例如：n=7，k=3，下面三种分法被认为是相同的。1，1，5;1，5，1;5，1，1;问有多少种不同的分法。
"SQL操作全面介绍及常见问题讲解，必备查询语句大全
查询结果集合中数据的排列顺序与选择列表中指定的列名排列顺序相同。例如，可以使用SELECT nickname,email FROM testtable查询testtable表中的nickname和email列。 还可以在选择列表中更改列标题。可以使用列标题=...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值