【数据结构】顺序表

于 2024-10-10 10:50:08 发布
阅读量757 收藏 15
点赞数 21
文章标签： 数据结构 c++ c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83251330/article/details/142771114
版权


🍃 如果觉得本系列文章内容还不错，欢迎订阅🚩
🎊个人主页:小编的个人主页
🎀 🎉欢迎大家点赞👍收藏⭐文章
✌️ 🤞 🤟 🤘 🤙 👈 👉 👆 🖕 👇 ☝️ 👍

目录

🐼前言

在上一节我们实现了通讯录，如果感兴趣的小伙伴，可以阅读我的上一篇文章:
通讯录，这一节要更客观的认识它的底层逻辑结构:顺序表

🐼线性表

首先我们来介绍线性表，线性表是n个具有相同特性的数据元素的有限序列。线性表是⼀种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的⼀条直线。但是在物理结构上并不⼀定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

🐼顺序表

顺序表是线性表的一种

顺序表是一段物理上的连续存储单元存储数据的线性结构，一般用数组存储，顺序表分为两种，静态顺序表和动态顺序表，定义如下:

typedef int SLDataType;
//静态顺序表
#define MAX_SIZE 100
typedef struct SeqList
{
	SLDataType data[MAX_SIZE];
	int size;//顺序表中有效元素的个数
}SL;
 
//动态顺序表
typedef struct SeqList
{
	SLDataType* data;
	int size;//顺序表中有效元素的个数
	int capacity;//容量大小
}SL;

静态顺序表顾名思义，数组的个数是固定的。静态顺序表缺陷：空间给少了不够用，给多了造成空间浪费。
动态顺序表在静态循序表的基础上，又增加了一个结构体变量capacity
当capacity == size 时，我们增容，从而实现了动态的功能。
动态顺序表缺陷：频繁增容，可能会有多个内存碎片，造成内存泄露。
相比于静态顺序表的数据流失，动态顺序表显然更好，所以我们用动态顺序表来实现顺序表

在顺序表的实现中，我们要手动实现顺序表的初始化，销毁顺序表，打印，尾插，头插，尾删，头删，在指定位置之前插入数据，查找指定位置数据，以及删除指定位置的数据现在我们来一一实现。

🐼 初始化

/顺序表的初始化
void SLInit(SL* ps)
{
	ps->data = NULL;
	ps->capacity = ps->size = 0;
}

🌻代码解析

上述代码我们对ps指向的data数组开辟的那块内存空间置空，并将顺序表有效的数据元素和容量大小置为0。

🐼尾插

尾插的逻辑很简单，在arr中插入有效元素，并让size++，但是，在插入数据时，是否有空间让我们尾插呢?所以我们首先要检查是否有空间来支持我们插入，如果有空间，则直接尾插，没有空间，让操作系统申请空间以便于让我们尾插
所以我们在插入元素之前，首先要检查是否需要增容，要增容，那我们增容，不增容，执行尾插操作
这里我们封装一个函数CheakCapacity()来检查是否需要增容。

🐼增容

void CheakCapacity(SL* pc)
{
	//判断是否是要增容
	if (pc->size == pc->capacity)
	{
		//增容
		int newcapacity = pc->capacity == 0 ? 4 : 2 * pc->capacity;
		SLDataType* tmp =(SLDataType*) realloc(pc->data,newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("CheakCapacity()::fail");
			exit(1);
		}
		pc->data = tmp;
		pc->capacity = newcapacity;
	}
}

🌻代码解析

我们用pc->size和pc->capacity是否相等判断是否需要增容，如果需要增容，我们用realloc()函数来增容，将realloc的申请的空间先放在临时变量tmp中，增容的大小以2倍的方式增容，最后更新data和capacity.
时间复杂度为O(1),空间复杂度为O(1),只创建有效个变量
注意：以二倍方式增容是比较科学的，概率论为基础，既不会浪费太多空间，也不会频繁增容。

尾插代码

//尾插
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);//等价于assert(ps != NULL)
	//检查是否需要增容
	CheakCapacity(ps);
	
	ps->data[ps->size++] = x;
}

🌻代码解析

在尾插前，我们要先检查是否需要增容，然后更细数组中的内容和下标size
时间复杂度为O(1),空间复杂度为O(1),只创建有效个变量
如图:
在这里插入图片描述

🍀 测试结果:
在这里插入图片描述

🐼 展示顺序表

//展示顺序表
void SLDisplay(SL* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}

🌻代码解析

为了更直观的展示顺序表，我们通过有效元素的个数，一一打印出顺序表中的有效数据。
时间复杂度为O(N),只遍历一次顺序表，空间复杂度为O(1),只创建有效个变量

🐼 头插

//头插
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	//检查是否需要增容
	CheakCapacity(ps);
	//将size-1个数据整体向后移动一位
	for (int i = ps->size - 1; i >=0; i--)
	{
		ps->data[i + 1] = ps->data[i];
	}
	//将下标为0的位置空出来
	ps->data[0] = x;
	ps->size++;
}

🌻代码解析

头插与尾插相同，在插入过程中首先都需要先检查是否需要增容，然后将第0个下标之后的元素整体向后移动一位，
将下标为0的位置空出来，插入元素，完成头插操作
时间复杂度为O(N),只遍历一次顺序表，空间复杂度为O(1),只创建有效个变量
画图解析:
在这里插入图片描述

🍀 测试结果:
在这里插入图片描述

🐼 尾删

// 尾删
void SLPopBack(SL* ps)
{
	assert(ps && ps->size);
	//将有效元素的个数减一
	ps->data[ps->size--];
}

🌻代码解析

尾删代码很简单，要保证要删除的元素不为空并且ps不为空的前提下，我们只需要让有效元素减一，最后一个元素对于其他功能都是无作用的，当进行下一个操作时，会覆盖掉最后一个元素，从而达到了尾删的目的。
时间复杂度为O(1),空间复杂度为O(1),只创建有效个变量

🍀 测试结果:
在这里插入图片描述

🐼 头删

// 头删
void SLPopFront(SL* ps)
{
	assert(ps && ps->size);

	//整体数据往前挪动一位
	for (int i = 1; i <= ps->size - 1; i++)
	{
		ps->data[i - 1] = ps->data[i];
	}
	ps->size--;
}

🌻代码解析

头删也是要保证删除的顺序表不为空，然后整体向前挪动一位，覆盖掉前面数据，完成一次头删操作，最后更新size的值
时间复杂度为O(N),只遍历一次顺序表，空间复杂度为O(1),只创建有效个变量
🍀 测试结果:
在这里插入图片描述

🐼查找指定元素

//查找指定元素
int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	int i = ps->size;//保存有效元素的个数
	while (i--)
	{
		if (ps->data[i] == x)
			//找到返回下标
			return i;
	}
	//返回无效下标
	return -1;
}

🌻代码解析

为了不改变size的值，用i从后往前遍历顺序表，如果找到了该数据，返回下标，没有找到返回无效下标。
时间复杂度为O(N),只遍历一次顺序表，空间复杂度为O(1),只创建有效个变量

🍀 测试结果:
在这里插入图片描述

🐼在指定位置之前插入数据

//在指定位置之前插入数据
void Insert(SL* ps, SLDataType pos, SLDataType x)
{
	assert(ps);
	assert(ps->size >= pos && pos>=0);
	//空间足够才能插入数据
	CheakCapacity(ps);

	//将pos后的数据整体挪动向后一位
	for (int i = ps->size - 1; i >=pos; i--)
	{
		ps->data[i + 1] = ps->data[i];
	}
	//插入数据
	ps->data[pos] = x;
	ps->size++;
}

🌻代码解析

要保证插入的位置是<=size的，等于pos = size时，相当于尾插,pos等于0，相当于头插。在插入前要检查是否有空间插入。插入过程先将将pos后的数据整体挪动向后一位，空出下标为pos的位置，插入数据。
时间复杂度为O(N),只遍历一次顺序表，空间复杂度为O(1),只创建有效个变量
画图分析:
在这里插入图片描述

🍀 测试结果:

在2前面插入数据:

在这里插入图片描述

🐼删除指定位置

/删除指定位置数据
void Erase(SL* ps, SLDataType pos)
{
	assert(ps);
	//有元素才能删
	assert(ps->size >= pos && pos >= 0);
	//将pos后的位置整体向前挪动一位
	for (int i = pos; i < ps->size-1; i++)
	{
		ps->data[i] = ps->data[i + 1];
	}
	ps->size--;
}

🌻代码解析

要删除的元素下标是要存在的，用assert来暴力解决限制，在删除时将pos后的位置整体向前挪动一位，实现覆盖pos，最后，更新size的值，完成删除操作
时间复杂度为O(N),只遍历一次顺序表，空间复杂度为O(1),只创建有效个变量
画图解析:
在这里插入图片描述

🍀 测试结果:
在这里插入图片描述

🐼销毁顺序表

//销毁顺序表
void Destroy(SL* ps)
{
	assert(ps);
	//指向空间存在销毁
	if (ps->data)
	{
		free(ps->data);
	}
	ps->data = NULL;
	ps->size = ps->capacity = 0;
}

🌻代码解析

释放ps指向的那块空间，并将成员变量capacity和size置为0

🐼全部源码

SeqList.h

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

typedef int SLDataType;
//静态顺序表
//#define MAX_SIZE 100
//typedef struct SeqList
//{
//	SLDataType data[MAX_SIZE];
//	int size;//顺序表中有效元素的个数
//}SL;
// 

//动态顺序表
typedef struct SeqList
{
	SLDataType* data;
	int size;//顺序表中有效元素的个数
	int capacity;//容量大小
}SL;

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

//展示顺序表
void SLDisplay(SL* ps);

//尾插
void SLPushBack(SL* ps, SLDataType x);

//头插
void SLPushFront(SL* ps, SLDataType x);

// 尾删
void SLPopBack(SL * ps);

// 头删
void SLPopFront(SL* ps);

//查找指定元素
int SLFind(SL* ps, SLDataType x);

//在指定位置之前插入数据
void Insert(SL* ps, SLDataType pos, SLDataType x);

//删除指定位置数据
void Erase(SL* ps, SLDataType pos);

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

SeqList.c

#define  _CRT_SECURE_NO_WARNINGS
#include "SqList.h"

//顺序表的初始化
void SLInit(SL* ps)
{
	ps->data = NULL;
	ps->capacity = ps->size = 0;
}

void CheakCapacity(SL* pc)
{
	if (pc->size == pc->capacity)
	{
		//增容
		int newcapacity = pc->capacity == 0 ? 4 : 2 * pc->capacity;
		SLDataType* tmp =(SLDataType*) realloc(pc->data,newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("CheakCapacity()::fail");
			exit(1);
		}
		pc->data = tmp;
		pc->capacity = newcapacity;
	}
}

//尾插
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);//等价于assert(ps != NULL)
	//检查是否需要增容
	CheakCapacity(ps);
	
	ps->data[ps->size++] = x;
}

//头插
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	//检查是否需要增容
	CheakCapacity(ps);
	//将size-1个数据整体向后移动一位
	for (int i = ps->size - 1; i >=0; i--)
	{
		ps->data[i + 1] = ps->data[i];
	}
	//将下标为0的位置空出来
	ps->data[0] = x;
	ps->size++;
}


//展示顺序表
void SLDisplay(SL* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}

// 尾删
void SLPopBack(SL* ps)
{
	assert(ps && ps->size);
	//将有效元素的个数减一
	ps->data[ps->size--];
}

// 头删
void SLPopFront(SL* ps)
{
	assert(ps && ps->size);

	//整体数据往前挪动一位
	for (int i = 1; i <= ps->size - 1; i++)
	{
		ps->data[i - 1] = ps->data[i];
	}
	ps->size--;
}

//查找指定元素
int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	int i = ps->size;//保存有效元素的个数
	while (i--)
	{
		if (ps->data[i] == x)
			//找到返回下标
			return i;
	}
	//返回无效下标
	return -1;
}

//在指定位置之前插入数据
void Insert(SL* ps, SLDataType pos, SLDataType x)
{
	assert(ps);
	assert(ps->size >= pos && pos>=0);
	//空间足够才能插入数据
	CheakCapacity(ps);

	//将pos后的数据整体挪动向后一位
	for (int i = ps->size - 1; i >=pos; i--)
	{
		ps->data[i + 1] = ps->data[i];
	}
	//插入数据
	ps->data[pos] = x;
	ps->size++;
}

//删除指定位置数据
void Erase(SL* ps, SLDataType pos)
{
	assert(ps);
	//有元素才能删
	assert(ps->size >= pos && pos >= 0);
	//将pos后的位置整体向前挪动一位
	for (int i = pos; i < ps->size-1; i++)
	{
		ps->data[i] = ps->data[i + 1];
	}
	ps->size--;
}

//销毁顺序表
void Destroy(SL* ps)
{
	assert(ps);
	//指向空间存在销毁
	if (ps->data)
	{
		free(ps->data);
	}
	ps->data = NULL;
	ps->size = ps->capacity = 0;
}

test.c

#define  _CRT_SECURE_NO_WARNINGS
#include "SqList.h"

void Test01()
{
	SL sl;
	SLInit(&sl);
	/*SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);*/
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLDisplay(&sl);
	/*SLDisplay(&sl);
	SLPopBack(&sl);
	SLDisplay(&sl);
	SLPopBack(&sl);
	SLDisplay(&sl);
	SLPopBack(&sl);
	SLDisplay(&sl);
	SLPopBack(&sl);
	SLDisplay(&sl);*/
	/*SLPopFront(&sl);
	SLDisplay(&sl);
	SLPopFront(&sl);
	SLDisplay(&sl);
	SLPopFront(&sl);
	SLDisplay(&sl);
	SLPopFront(&sl);
	SLDisplay(&sl);*/
	int ret = SLFind(&sl, 3);
	/*if (ret != -1)
		printf("找到了\n");
	else
		printf("没找到\n");*/
	//Insert(&sl, ret, 66);
	Erase(&sl, ret);
	SLDisplay(&sl);
}
int main()
{
	Test01();
}

🐼文末

感谢你看到这里，如果觉得本篇文章对你有帮助，点个赞👍 吧，你的点赞就是我更新的最大动力 ⛅️🌈 ☀️

此生只爱蛋
关注
数据结构 顺序表学习总结
sumandavg的博客
10-24 1541
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。 目录前言1. 顺序表介绍1.1 什么是顺序表1.2 顺序表的性质1.3 顺序表的构成1.4 顺序表的框架代码（C++版）2. 顺序表的操作2.1 初始化顺序表2.1.1 步骤2.1.2 代码展示2.2 顺序表的插入2.2.1 步骤2.2.2 代码展示2.3 顺序表的扩容2.3.1 步骤2.3.2 代码展示2.4 顺序表的查询2.4.1 步骤2.4.
合工大数据结构顺序表实验
04-14
本实验“合工大数据结构顺序表实验”聚焦于数据结构中的一个重要基础概念——顺序表。顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储，就像数组一样。对于18级合工大的学生来说，这个实验旨在深化他们...
c++数据结构顺序表实现
cangyue_a的博客
04-05 2759
c++数据结构中的方法通过面向对象的机制提高了程序的效率。
数据结构-顺序表基本操作的实现（含全部代码）
热门推荐
关注网络安全、云原生安全
09-13 21万+
今天起开始编写数据结构中的各种数据结构及其算法的实现。 主要依据严蔚敏版数据结构教材以及王道数据结构考研辅导书。 今天是线性表中的顺序表的实现，主要实现函数如下，读者有需要可以评论，我可以适当加几个。 CreatList(SqList &L,int n) 参数：顺序表L，顺序表长度n 功能：创建长度为的顺序表 时间复杂度：O(n) InitList(SqList &...
数据结构：顺序表详解
Zhenyu_Coder的博客
07-30 5947
顺序表作为一种基本的数据结构，在许多应用场景中具有重要的意义和作用，可以提高数据的访问和操作效率，简化算法设计，提高内存利用率。本篇博客将向你详细介绍其模拟过程及全代码
数据结构 顺序表的查找
weixin_57500505的博客
12-09 2798
按值查找顺序表。请在程序中建立一个含有10个元素，分别是1,2,3,4,5,6,7,8,9,10的顺序表。然后等候用户输入要查找的元素值，如顺序表中有该元素，则输出该元素位序，否则输出查找失败。 【输入】要查找的元素值 【输出】该元素位序 或查找失败 代码 #include<iostream> using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int ElemType.
数据结构 顺序表实现手机通讯录
taotu_tao的博客
03-29 6067
代码 #include <stdio.h> #include <malloc.h> #include <string.h> #include <stdlib.h> #include <windows.h> #include <conio.h> //#include <stack> typedef struct { char name[10]; char tel[12]; }ElemType; typedef s
＜数据结构＞ 顺序表
bit_zyx的博客
03-13 9876
目录 一、顺序表介绍 二、准备工作 1、创建顺序表 2、初始化顺序表 3、检测是否需要扩容 4、销毁顺序表 5、打印顺序表 三、四大功能 1、增加数据 头插 尾插 指定下标插入 2、删除数据 头删 ...
数据结构（顺序表）
小马同学的博客
11-07 2409
数据机构的顺序表实现
数据结构——顺序表
2301_77179941的博客
04-17 8278
​ 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 ​
数据结构之顺序表
aaa1336的博客
10-15 3468
简单的说，线性表就是一个数组，不过实现的时候我们把这个数组放在一个结构体里面，再记录一下有效元素的个数，就可以了。从数据结构的角度来看，数据元素之间的逻辑关系是线性的，存储结构是顺序存储。
头歌数据结构顺序表的基本操作1-6关
05-18
【顺序表】是一种基本的数据结构，它在计算机科学中被广泛使用，特别是在处理大量有序或无序数据时。顺序表的实现通常是通过数组来完成的，数组中的元素按顺序存储，便于快速访问和操作。本题涉及顺序表的六种基本...
数据结构顺序表c++代码
12-06
本文将深入探讨“数据结构顺序表”的概念以及如何使用C++实现它的基本操作，包括创建、查找、插入和删除。 顺序表，顾名思义，是元素在内存中按照线性顺序排列的数组。它具有连续的存储空间，每个元素都有一个固定...
C语言数据结构顺序表 学生表 学生成绩管理系统.zip
06-25
本项目以"C语言数据结构顺序表 学生表 学生成绩管理系统"为主题，涉及到的核心知识点包括顺序表、学生表的设计以及如何用C语言构建一个简单的学生成绩管理系统。 首先，我们来讨论“顺序表”。顺序表是一种基础的...
数据结构 顺序表 （c++实现）代码讲解
09-27
这是讲解代码中函数关系的Keynote 为了大家方便，已转换为ppt 博客地址blog.csdn.net/u012350104
指针（6）
最新发布
2402_82715436的博客
10-06 434
qsort 实现
Java.数据结构.TreeMap
TJKFYY的博客
10-03 316
TreeMap是Java集合框架中的一部分，并且基于红黑树数据结构。这说明TreeMap能够高效地执行键值对的存储、检索、排序等操作。TreeMap会根据键的自然顺序进行排序，当然，你也可以通过重写Comparator自己来进行排序。TreeMap中的键是唯一的，不能重复。如果有两个键相等，则后插入的值会覆盖先前的值。TreeMap是基于红黑树实现的，其时间复杂度为O(log n)。判断是否包含Value。三、TreeMap的基本操作。一、什么是TreeMap。二、TreeMap的特点。
数据结构（染色法判定二分图）
yyssas的博客
10-03 346
对于每个点进行判断，若当前的点未染色，则染成一个颜色，然后对于相连接的点，都染成另一种颜色，若有相连的点已经有颜色，则进行判断，若是同一种颜色则不是二分图，返回false，若所有点染色都成功，则是二分图，返回true。这所以这样做，是因为有些点之间可能不存在通路，所以要对所有点都进行染色。染色法基于一个定理，即奇数点构成的环一定不是二分图，证明：假如是同一类的两个同类的点相连，则在环除了这两个点以外的点，应该都满足交叉的，则必定会有奇数个，再加上这两个点，一共是奇数个点，因此一定不是二分图。
栈数据结构:定义，基本操作与应用
m0_66847953的博客
10-03 898
栈（Stack）是一种特殊的线性数据结构，其插入和删除操作都只允许在表的一端进行。这一端被称为栈顶（top），另一端则被称为栈底（bottom）。栈遵循后进先出（Last In First Out，LIFO）的规则，即最后存入的元素将被最先取出。顺序栈采用一个数组存放栈中的元素。如果需要用到两个类型相同的栈，这时若为它们各自开辟一个数组空间,极有可能出现这样的情况：第一个栈已满,再进栈就溢出了，而另一个栈还有很多空闲的存储空间。解决这个问题的方法是。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值