【数据结构之顺序表超详解（保姆级教程）】

最新推荐文章于 2023-08-14 13:59:51 发布
最新推荐文章于 2023-08-14 13:59:51 发布
阅读量1.3k 收藏 3
点赞数 18
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52882232/article/details/121917086
版权

顺序表超详解

顺序表

顺序表的基本概念：
用一组地址连续的存储单元一次存储线性表的数据元素。

1.顺序表的特点

  1. 可动态增长的数组
  2. 数据在数组中存储时必须是连续的

缺点

  1. 中间或头部的插入删除很慢，需要挪动数据，时间复杂度是O(N)
  2. 空间不够时，增容会有一定消耗和空间浪费

优点：

  1. 随机访问（随机存取）
  2. 缓存利用率较高

2.顺序表的定义

静态顺序表

typedef int SLDataType;
#define N 10;
//顺序表的静态存储
typedef struct SeqList
{
	SLDataType a[N];//定长数组
	SLDataType size;//有效数据的个数
}SL,SeqList;

动态顺序表

/顺序表，有效数组在数组中必须是连续
//动态顺序表设计(大小可变)
typedef int SLDataType;
#define N 10;

typedef struct SeqList
{
	SLDataType* a;//指向动态开辟的数组
	SLDataType size;//有效数据个数
	SLDataType capicity;//容量空间大小
}SL,SeqList;

本篇文章主要讨论动态顺序表的增删查改。

3.顺序表的初始化

//顺序表初始化
void SeqListInit(SL* ps)
{
	/*s.size = 0;
	s.a = NULL;
	s.capicity = 0;*/
	ps->a = (SLDataType* )malloc(sizeof(SLDataType) * 4);
	if (ps->a == NULL)
	{
		printf("申请位置失败\n");
		exit(-1);
	}

	ps->size = 0;
	ps->capicity = 4;
}

4.顺序表的扩容

在顺序表中插入的时候，我们会遇到顺序表内存不足的情况，那么我们这个时候就需要给顺序表扩容
那么我们如何去扩容呢？
显然最简单的扩一个单位，但万一需要插入的是100个元素呢，这就得扩容100次，效率显然就降低了，有的同学就会说那我们就扩容10000个，显然这也并不合理，万一只插入一个元素呢。
所以，基于上诉两种情况，我们可以每次给顺序表扩容2倍，就是把原来的大小*2，但这也只是一个折中的办法，仍然会出现地址空余造成空间浪费的情况，这是顺序表不可避免的。

void SeqListCheckCapacity(SL* ps)
{
	//如果满了需要增容
	if (ps->size >= ps->capicity)
	{
		ps->capicity *= 2;
		ps->a = (SLDataType*)realloc(ps->a, sizeof
		(SLDataType) *ps->capicity);
		if (ps->a == NULL)
		{
			printf("扩容失败\n");
			exit(-1);
		}
	}
}

5.顺序表打印

用于观察自己所写的接口是否正确

void SeqListprint(SL* ps)
{
	assert(ps);

	//如果满了需要增容
	SeqListCheckCapacity(ps);
	for (int i = 0; i < ps->size; ++i)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

6.顺序表的插入

在对顺序表操作时，我们首先要做的就是判断顺序表的指针和传入的pos是否合法，教材上呢用的是下面的代码来对pos判断是否合法。
在这呢，博主给大家介绍一格 函数：断言函数（assert），它是cassert…h下的一个函数，就是来判断assert（）里的是否合法，不合法就直接终止程序，很好用。

if(i < 1 || i>L.size+1) return -1;

6.1.头插

void SeqListPushFront(SL* ps, SLDataType x)
{
    assert(ps);

	SeqListCheckCapacity(ps);//判断顺序表是否需要扩容，如果需要就扩容
	
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];//把顺序表的元素依次后推一个单位
		--end;
	}

	ps->a[0] = x;//将x插入顺序表的表头
	ps->size++;

	//SeqListInsert(ps,0,x);任意位置实现的头插法
}

6.2.尾插

void SeqListPushBack(SL* ps, SLDataType x)
{
	assert(ps);

	SeqListCheckCapacity(ps);//判断顺序表是否需要扩容，如果需要就扩容
	ps->a[ps->size] = x;
	ps->size++;

	//SeqListInsert(ps, ps->size, x);任意位置实现的尾插法
}

6.3.任意位置的插入

//任意位置插入删除
void SeqListInsert(SL* ps, int pos,SLDataType x)
{
	assert(ps);
	assert(pos <= ps->size && pos >= 0);

	SeqListCheckCapacity(ps);

	int end = ps->size - 1;
	while (end >= pos)//找到插入位置
	{
		ps->a[end + 1] = ps->a[end];//将后面的元素倒推一个单位
		--end;//判断循环是否终止
	}
	ps->a[pos] = x;
	ps->size++;//插入后size加一
}

7.顺序表的删除

7.1.头删

void SeqListPopFront(SL* ps) 
{
	assert(ps);

	int start = 0;
	while (start < ps->size-1)
	{
		ps->a[start] = ps->a[start + 1];//把每个元素前一一个单位，头部的数据就自然被取代了
		++start;
	}

	ps->size--;
	//SeqListErase(ps, 0);
}

7.2.尾删

void SeqListPopBack(SL* ps)
{
	assert(ps);

	ps->a[ps->size - 1] = 0;
	ps->size--;
	
	//SeqListErase(ps, ps->size - 1);
}

7.3.任意位置的删除

void SeqListErase(SL* ps, SLDataType pos)
{
	assert(ps);
	assert(pos <= ps->size && pos >= 0);

	int start = pos;//start为要删除的位置
	while (start < ps->size - 1)
	{
		ps->a[start] = ps->a[start + 1];//数据后移一个单位
		++start;
	}

	ps->size--;//删除后size-1
}

8.顺序表的查找

//顺序表查找
int SeqListFind(SL* ps, SLDataType x)
{
	assert(ps);

	int i = 0;
	while (i < ps->size)
	{
		if (ps->a[i] == x)
		{
			return i;
		}

		++i;
	}

	return -1;//顺序表里没有x，查找失败
}

9.顺序表的销毁

每次运行完后，建议将测试的顺序表删除，以释放空间

//顺序表销毁
void SeqListDestroty(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->size = 0;
	ps->capicity = 0;
}

10.顺序表的完整代码（接口实现）

10.1.头文件

命名为：list.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include <cassert>

//顺序表，有效数组在数组中必须是连续
//动态顺序表设计(大小可变)
typedef int SLDataType;
#define N 10;

typedef struct SeqList
{
	SLDataType* a;//指向动态开辟的数组
	SLDataType size;//有效数据个数
	SLDataType capicity;//容量空间大小
}SL,SeqList;

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

//顺序表销毁
void SeqListDestroty(SL *ps);
//尾插尾删
void SeqListPushBack(SL* ps, SLDataType x);
void SeqListPopBack(SL* ps);

//头插头删
void SeqListPushFront(SL* ps, SLDataType x);
void SeqListPopFront(SL* ps);

void SeqListCheckCapacity(SL* ps);

//任意位置插入删除
void SeqListInsert(SL* ps, int pos,
	SLDataType x);
void SeqListErase(SL* ps, SLDataType pos);

//顺序表查找
int SeqListFind(SL* ps1, SLDataType x);

10.2.接口的实现

#include"list.h"

//顺序表初始化
void SeqListInit(SL* ps)
{
	/*s.size = 0;
	s.a = NULL;
	s.capicity = 0;*/
	ps->a = (SLDataType* )malloc(sizeof(SLDataType) * 4);
	if (ps->a == NULL)
	{
		printf("申请位置失败\n");
		exit(-1);
	}

	ps->size = 0;
	ps->capicity = 4;
}

//顺序表销毁
void SeqListDestroty(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->size = 0;
	ps->capicity = 0;
}

//顺序表打印
void SeqListprint(SL* ps)
{
	assert(ps);

	//如果满了需要增容
	SeqListCheckCapacity(ps);
	for (int i = 0; i < ps->size; ++i)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

void SeqListCheckCapacity(SL* ps)
{
	//如果满了需要增容
	if (ps->size >= ps->capicity)
	{
		ps->capicity *= 2;
		ps->a = (SLDataType*)realloc(ps->a, sizeof
		(SLDataType) *ps->capicity);
		if (ps->a == NULL)
		{
			printf("扩容失败\n");
			exit(-1);
		}
	}
}
// 尾插尾删
	void SeqListPushBack(SL* ps, SLDataType x)
{
	/*assert(ps);

	SeqListCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;*/

	SeqListInsert(ps, ps->size, x);
}

void SeqListPopBack(SL* ps)
{
	/*assert(ps);

	ps->a[ps->size - 1] = 0;
	ps->size--;*/
	SeqListErase(ps, ps->size - 1);
}

//头插头删
void SeqListPushFront(SL* ps, SLDataType x)
{
	/*int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}

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

	SeqListInsert(ps,0,x);
}

void SeqListPopFront(SL* ps) 
{
	/*assert(ps);

	int start = 0;
	while (start < ps->size-1)
	{
		ps->a[start] = ps->a[start + 1];
		++start;
	}

	ps->size--;*/
	SeqListErase(ps, 0);
}

//任意位置插入删除
void SeqListInsert(SL* ps, int pos,SLDataType x)
{
	assert(ps);
	assert(pos <= ps->size && pos >= 0);

	SeqListCheckCapacity(ps);

	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}
void SeqListErase(SL* ps, SLDataType pos)
{
	assert(ps);
	assert(pos <= ps->size && pos >= 0);

	int start = pos;
	while (start < ps->size - 1)
	{
		ps->a[start] = ps->a[start + 1];
		++start;
	}

	ps->size--;
}

//顺序表查找
int SeqListFind(SL* ps, SLDataType x)
{
	assert(ps);

	int i = 0;
	while (i < ps->size)
	{
		if (ps->a[i] == x)
		{
			return i;
		}

		++i;
	}

	return -1;
}

10.3.测试文件

命名为：text.c
使用一个函数将测试的函数封装起来，便于测试多组数据
这种方法更规范，也更高逼格。

#include"list.h"
void SeqListprint(SL* ps);

//测试头尾插入删除
void TestSeqList1()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 6);
	SeqListPushBack(&s, 7);
	SeqListPushBack(&s, 8);
	//SeqListPushBack(&s, 9);
	SeqListprint(&s);

	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListprint(&s);

	SeqListPushFront(&s,-1);
	SeqListPushFront(&s, -2);
	SeqListPushFront(&s, -3);
	//SeqListPopBack(&s);
	SeqListprint(&s);

	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListprint(&s);

	int pos = SeqListFind(&s, 5);
	if (pos != -1)
	{
		SeqListErase(&s, pos);
	}
	SeqListprint(&s);
}
int main()
{
	TestSeqList1();

	return 0;
}

11.总结

本文的代码相对于教材的代码更易于初学者理解、熟悉，本文代码的函数的命名和C++的函数库STL类似，这样同学们以后学到c++的STL库的时候就更容易上手。最后敲完一遍代码后，最好再手写一遍代码，以加深对代码的印象和理解，而且以后面试也要手写代码的，就当作练习了。

博主也希望同学们看了本文后能有一定的收获，喜欢本文的话可以一键三连。

最后，本文涉及到动态内存和函数的知识，有不懂的同学可以看一下下面的两个文章
如果对动态内存分布有不懂的可以点这，舔狗级讲解

对函数不理解的点这，同样的舔狗级讲解

贩梦先生007
关注
  • 18
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 12
    评论
专栏目录
C语言数据结构-顺序表的插入与删除(图文详解)
weixin_45745641的博客
11-09 5845
内容概要 本篇推文主要给大家介绍顺序表插入和删除的操作原理以及其具体的代码实现，了解顺序表的几种基本运算，要注意理解插入删除算法的原理掌握其实现代码 顺序表的基本运算 顺序表的插入运算 顺序表上完成插入运算的步骤如下: 将第n个至第i个位置的元素顺序向后移动一个位置，为新元素空出第i个位置。 将x置入空出的第i个位置。 表长加1。 代码实现 int Insert_SeqList (SeqList *L,ElemType x,int i) { //在下标为i的位置插入新元素 int k;
数据结构学习笔记：顺序表的删除操作及其演化题目总结
小宇y的博客
03-23 9429
目录前言例题类似题目1类似题目2类似题目3题目4结语 前言例题 例、设计一个删除算法，删除顺序表L中的第i个位置的元素，用引用变量返回。 思路： 由于这个函数删除后顺序表L有变，所以L前要有&，且我们要返回的变量一开始为初始值0，它也是变化的，所以该变量前面也要加引用。 bool ListDelete(SqList &L,i
顺序表的删除
m0_63341217的博客
10-18 3362
顺序表的删除
[数据结构]顺序表的基本操作——删除
m0_64973566的博客
03-07 6549
……………………………………………………………………………… 以下内容注意int &e; &表示的是e是引用变量。此时，删除方法中的变量e和main函数中的变量e在内存中对应的是同一份数据。 若e不是引用型变量，则main函数中声明了一个局部于main函数的变量e，并且调用了删除函数，但由于这个参数e不再是引用型变量会导致删除方法中处理的e是main函数中变量e的复制品。尽管main函数和删除方法中的变量e名称一样，但在内存中对应的是两份不同的数据，...
数据结构之顺序表的删除、查找、遍历
qq_40022596的博客
04-27 4156
一、引言 本篇文章作为顺序表新的篇章延续上一篇文章（）的内容
C#数据结构之顺序表(SeqList)实例详解
09-03
顺序表是一种常见的线性数据结构，它在计算机科学中扮演着重要角色。在C#中，顺序表通常通过数组来实现，因为数组在内存中是连续分配的，这使得我们可以快速地访问任意位置的元素，实现所谓的“随机存取”。 顺序表...
数据结构之顺序表.rar
04-07
顺序表是一种基本的数据结构，它是线性表的一种存储方式，其中元素在计算机内存中的存储是连续的，就像一串珠子一样串联在一起。在C++中实现顺序表，我们需要掌握以下几个核心知识点： 1. **数组基础**：顺序表的...
Python数据结构之顺序表的实现代码示例
09-21
顺序表是一种常见的数据结构，它在计算机科学中扮演着重要角色。在Python中，我们可以使用内置的列表类型来实现顺序表，但为了更好地理解数据结构的概念，下面我们将深入探讨顺序表的原理，并展示如何自定义一个顺序...
PTA—C语言数据结构：顺序表.ppt
10-11
PTA平台数据结构课程顺序表参考答案
7-7 顺序表（删除） (10 分)
LancasterLiu的博客
07-19 1432
7-7 顺序表（删除） (10 分) 已知一组数据，采用顺序存储结构存储，其中所有的元素为整数。设计一个算法，删除元素值在[x,y]之间的所有元素 输入格式: 输入包含三行数据，第一行是表中元素个数，第二行是顺序表的各个元素，第三行是区间x和y。 输出格式: 删除元素值在[x,y]之间的所有元素后，输出新的顺序表。(最后无空格) 样例 输入样例: 在这里给出一组输入。例如： 10 55 11 9 15 67 12 18 33 6 22 10 20 输出样例: 在这里给出相应的输出。例如： 55 9 67 3
顺序表删除元素
weixin_56933315的博客
07-26 9924
顺序表删除的两种办法，删除某一个元素，删除所有值为X的元素
顺序表的插入，删除，修改和查找（详细解析）
最新发布
weixin_69884785的博客
08-14 3759
顺序表的插入，删除，修改和查找（详细解析）相对基础，多看多理解多写
顺序表的插入和删除（数据结构）
热门推荐
shoushou_的博客
07-23 2万+
1.问题描述 顺序表的插入和删除是数据结构中比较基础的，在插入部分要能够做到在数组头部插入数据，在尾部插入数据，以及在指定位置插入指定数据。在删除部分要能够做到删除尾部数据，删除头部数据，删除指定位置的数据。 2.问题分析 在对象中设置一个属性size来表示数组中数据的长度，同时自然也少不了一个属性是数组。一般来将，给数组尾部插入一个数据或者删除数组尾部的数据比较简单，直接把下标为size++或者...
顺序表的删除（按位置删、头删、尾删）
qq_45829112的博客
10-20 1091
顺序表的结构体设计： #define MAXSIZE 10 //顺序表一般固定大小 struct SeqList { int data[MAXSIZE]; int capacity； //顺序表容量大小 int cursize; //顺序表中有效数据节点个数 }SeqList , *PSeqList; //结构体指针和结构体别名 按位置删除： bool Eraser(PSeqList plist, int pos) { assert(plist !=
顺序表的删除操作
qq_63797077的博客
01-08 1496
顺序表是一种线性数据结构，它由一组有序的数据元素组成。顺序表中的数据元素是按照一定顺序存储的，并且可以通过数据元素的位置来访问它们。顺序表有以下几个特点：顺序表的查找效率高，可以通过数组下标直接访问顺序表中的任意一个数据元素。顺序表的插入和删除效率较低，因为这些操作需要移动大量的数据元素。顺序表的空间利用率较低，因为顺序表的大小是固定的，如果空间不够用，就需要重新分配一块新的内存空间，将数据复制过去，这样就会浪费一些空间。顺序表的内存空间是连续的，这样可以提高缓存命中率，从而提高访问效率。
二叉树-删除节点（简单）
weixin_52725999的博客
08-09 773
13.1.2 二叉树-删除节点（简单） 要求： 如果删除的节点是叶子节点，则删除该节点 入关删除的节点是非子叶节点，则删除该子树 思路： 因为我们的二叉树是单向的，没办法找到前驱节点，所以我们判断当前节点的子节点是否需要删除，而不能去判断当前节点是不是需要删除的节点 先判断当前节点的左子节点不为空，并且左子节点就是要删除的节点，this.left = null,并且返回（结束删除工作） 如果当前节点的右子节点不为空，并且右子节点就是要删除的节点，this.right = null，并且返回（结束删除工
顺序表的插入和删除
hibugs
07-05 8686
顺序表插入和删除的代码实现、时间复杂度以及优缺点等
数据结构常用算法实现print.doc
12-27
数据结构常用算法实现print.doc

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

贩梦先生007

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值