顺序表详解（如何实现顺序表）

LaNzikinh2024-02-22 13:52

文章目录

前言

在进入顺序表前，我们先要明白，数据结构的基本概念。

一、 数据结构的基本概念

1.1什么是数据结构

数据结构是由"数据"和"结构"两词组合而来。所谓数据就是？常见的数值1、2、3、4.....、姓名、性别、年龄，等。这些都是数据。所谓结构就是当我们想要使用大量同⼀类型的数据时，我们可以借助数组这样的数据结构将大量的数据组织在⼀起，结构也可以理解为组织数据的方式。

1.2数据结构的两个层次

数据结构的两个层次分为逻辑结构和存储结构，逻辑结构与数据的存储无关独立于计算机从具体问题抽象出来的数学模型模。逻辑结构分为线性结构和非线性结构，这里不再强调。存储结构分为顺式存储结构和链式存储结构，今天我们所说的顺序表就是顺数存储结构，链式存储结构的代表就是链表。

1.3最基础的数据结构：数组

二.顺序表的概念及结构

概念：之前说了最基础的数据结构就是数组，它的概念:顺序表其实就是数组，但是在宿主的基础上，他还要求数据必须从头开始连续存放，并且中间不能跳跃间隔。

2.1结构

顺序表它分为静态顺序表和动态顺序表

静态顺序表

静态顺序表需要用#define来开辟，静态的特点就是N给小了不够用，给大了又浪费，所以我们所说的顺序表一般都是指的动态顺序表。

动态顺序表

2.2接口函数

接口函数就是某个模块写了（主要）给其它模块用的函数。简单的说接口函数就是类中的公有数。顺序表的实现主要是以接口函数来实现的

**三.**动态顺序表的实现

顺序表（seplist），我们重命名为SL，完成这个它我们使用3个文件，SL.h来放函数的声明，SL.cpp来放函数的定义，test.c来放可执行程序。

3.1一个经典的错误（初始化）

cpp 复制代码 
void SLInit(SL ps)
{
	ps.a = NULL;

	ps.size = ps.capacity = 0;

}

void testSL1()
{
    SL S1;
    SLInit(SL);
}

为什么这个代码无法运行？？？

因为在函数中的形参跟实参是有区别的形参的改变，不会影响到实参的，形参只是实参的一份临时拷贝，所以要用指针来找地址。

所以正确的初始化应该要这样

cpp 复制代码 
void SLInit(SL* ps)
{
	ps->a = NULL;

	ps->size = ps->capacity = 0;

}


void testSL1()
{
    SL S1;

    SLInit(&SL);
}

3.2接口函数之尾插

在一个数组中，如果我们想在末尾插入一个数，我们该怎么插入呢？这就是我们要想如何完成这个接口函数。

往末尾插东西，我们就要做到3点考虑，一.没有空间,刚刚好，二.空间不够的时候要进行扩容，三.空间足够的时候我们就直接插入。

先来看最容易的情况就是直接尾删

cpp 复制代码 
void SLpushBack(SL* ps, SLDataType x)
{
	ps->a[ps->size] = x;
	ps->size++;
}

然后我们在想我们前三点要注意的事情，如果没有空间或者空间不足了的话，我就要扩容，我们可以先将有效个数和空间容量相等来形成一个新的有效空间，这里我用了一个三目操作符，如果他们都等于零，我就给他付个值不等于零，我就翻倍在这个地方的扩容，我们就能想到realloc函数的扩容。过完之后我们还要判断一下，如果为空指针的话我们就要报警告，最后把我开辟的新空间重新付给a就可以了。

cpp 复制代码 
void SLPushBack(SL* ps, SLDataType x)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));

		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newcapacity;
	}

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

}

其实扩容这一步，我们完成了另外一种接口函数的使用，那就是检查扩容，我们可以用一个步骤来开辟一个新的结构函数就是检查扩容void SLCheckCapacity(SL* ps)；这样对于后面的来使用就会更加方便。

3.3接口函数之尾删

尾删就非常简单了，我们只要防止数组越界就可以了，我们这里利用断言来警告他不能越界。

cpp 复制代码 
void SLPopBack(SL* ps)
{
	assert(ps->size > 0);
	{
		ps->size--;
	}
}

3.4接口函数之头插

头插的话想在第一个数前放一个位置，我们就把已经存放的数每个都向后移一个，注意:如果容量空间已到最大则需开辟空间，所以这就用到了我们之前所讲的检查扩容这个接口函数，所以在头差之前我们先要来检查一下扩容，如果容量够就可以进行头差，如果不够就扩容。

cpp 复制代码 
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++;
}

3.5接口函数之头删

先思考为什么头删不可以size--???

因为根据顺序表的概念必须从头开始连续存放，并且中间不能跳跃间隔。

所以这个地方我们采取先挪动在尾删的方式。

cpp 复制代码 
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--;
}

3.6还原空间

因为我们之前动态开辟了内存，所以说我们肯定要把这个内存进行释放。

cpp 复制代码 
void SLDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

3.7接口函数之查找

查找的意思就是说找到对应元素所在的下标，即便他有多个也没关系，顺序表是从头到尾开始存放的，但是存放的内容不一定需要从头到尾他还可以存放字符等各种变量。

cpp 复制代码 
int SLFind(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[ps->size] == x)
		{
			return i;
		}
	}
	return -1;
}

3.8接口函数之在指定的pos下标位置插入

pos下标也是有要求，他不可以违背顺序表的概念

其实挪动方法都是一样的，不管是尾插还是头插它的移动方法其实是一样的

cpp 复制代码 
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while(end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

3.9接口函数之删除pos下标位置的数据

其实挪动方法都是一样的，不管是尾插还是头插它的移动方法其实是一样的，挪动的方式是一样的，只是可能方向不一样，做法是一样的，然后我们还是要判断下标的合法性

cpp 复制代码 
void SLErase(SL* ps, int pos)
{
	assert(pos >= 0 && pos < ps->size);
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
}

4.0复用

这个时候有没有突然间恍然大悟大！！！

之前写的头删尾删头差尾插好像都可以用pos去代替去完善

cpp 复制代码 
头删
void PushBack(SL* ps)
{
	SLErase(ps, ps->0);
}
尾删
void SLPopBack(SL* ps)
{
	SLErase(ps, ps->size-1);
}
头插
void SLPushFront(SL* ps, SLDataType x)
{
	SLInsert(ps, ps->0,X);
}
尾插
void SLpushBack(SL* ps, SLDataType x)
{
	SLInsert(ps, ps->size, X);
}

这就是复用。

四.整体的实现

cpp 复制代码 
SL.h
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//#define N 1000
typedef int SLDataType;
#pragma once
typedef struct SeqList
{
	SLDataType * a;//动态开辟的数组大小
	int size; // 有效数据个数
	int capacity; // 空间容量

}SL;
void SLInit (SL* ps);//初始化
void SLPrint(SL* ps);//打印
void SLCheckCapacity(SL* ps);//检查扩容
void SLDestory(SL* ps);//销毁，还原空间
void SLpushBack(SL* ps, SLDataType x);//尾插
void SLPopBack(SL* ps);//尾删
void SLPushFront(SL* ps, SLDataType x);//头插
void SLPopFront(SL* ps);//头删
int SLFind(SL* ps, SLDataType x);//查找
void SLInsert(SL* ps, int pos, SLDataType x);//在指定的pos下标位置插入
void SLErase(SL* ps, int pos);//删除pos位置的数据
cpp 复制代码 
SL.cpp
#include"SL.h"
//初始化
void SLInit(SL* ps)
{
	ps->a = NULL;
	ps->size = ps->capacity = 0;

}

//打印
void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d", ps->a[i]);
	}
	printf("\n");
}

//检查扩容
void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));

		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}

//销毁，还原空间
void SLDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

//尾插
void SLpushBack(SL* ps, SLDataType x)
{
	ps->a[ps->size] = x;
	ps->size++;
}

//尾删
void SLPopBack(SL* ps)
{
	assert(ps->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--;
}

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

//在指定的pos下标位置插入
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while(end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

//删除pos位置的数据
void SLErase(SL* ps, int pos)
{
	assert(pos >= 0 && pos < ps->size);
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
}

//头删
//void PushBack(SL* ps)
//{
//	SLErase(ps, ps->0);
//}
//尾删
//void SLPopBack(SL* ps)
//{
//	SLErase(ps, ps->size-1);
//}
//头插
//void SLPushFront(SL* ps, SLDataType x)
//{
//	SLInsert(ps, ps->0,X);
//}
//尾插
//void SLpushBack(SL* ps, SLDataType x)
//{
//	SLInsert(ps, ps->size, X);
//}

总结

有了顺序表，为什么还要学习其他的数据结构？顺序表作为数据结构的最基本，假设数据量非常庞大，频繁的获取数字，有效数据个数会影响程序的执行程序所以说最基础的数据结构提供的操作已经不能完全满足复杂的算法实现只有不断地提升自己才能变得强大。

相关推荐
Yawesh_best14 分钟前
思源笔记轻松连接本地Ollama大语言模型，开启AI写作新体验！
笔记·语言模型·ai写作
南宫生28 分钟前
贪心算法习题其三【力扣】【算法学习day.20】
java·数据结构·学习·算法·leetcode·贪心算法
希言JY37 分钟前
C字符串 | 字符串处理函数 | 使用 | 原理 | 实现
c语言·开发语言
午言若39 分钟前
C语言比较两个字符串是否相同
c语言
weixin_432702261 小时前
代码随想录算法训练营第五十五天|图论理论基础
数据结构·python·算法·深度优先·图论
CXDNW2 小时前
【网络面试篇】HTTP（2）（笔记）——http、https、http1.1、http2.0
网络·笔记·http·面试·https·http2.0
使者大牙2 小时前
【大语言模型学习笔记】第一篇：LLM大规模语言模型介绍
笔记·学习·语言模型
ssf-yasuo2 小时前
SPIRE: Semantic Prompt-Driven Image Restoration 论文阅读笔记
论文阅读·笔记·prompt
天行健PLUS2 小时前
【经验分享】六西格玛管理培训适合哪些人参加？
经验分享
passer__jw7672 小时前
【LeetCode】【算法】283. 移动零
数据结构·算法·leetcode
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play