【数据结构】线性表之——“顺序表”

已于 2023-04-20 07:26:02 修改
阅读量935 收藏 6
点赞数 12
分类专栏： 数据结构理解与实现 文章标签： 数据结构 c++ c语言
于 2023-04-19 19:52:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65596720/article/details/130251720
版权

文章目录

前言

  • 为什么有顺序表？由于数组定义之后不能扩充，我们需要一种更方便的结构来装载数据，顺序表诞生了。
  1. 顺序表是线性表的一种，线性表的存储都是形成一条线的，顺序表不仅仅在逻辑上是用一条线链接，在内存中也是连续的一块空间，因此可以进行下标随机访问。
  2. 顺序表不同于数组，顺序表在空间不够的情况下可以选择进行扩充。
  3. 顺序表不同于数组，顺序表开辟在堆空间中，不用担心栈空间不够用。
  4. 相对麻烦的就是，先对顺序表进行操作必须要自己实现增删改查等函数。
  5. 如果学会了顺序表可以试着自主完成通讯录小程序⭐

PS:需要源码直接通过目录跳转到最后

顺序表主体结构

默认大小与扩容大小还有类型都可以是任意大小或类型

#define SLDataType int
#define DEFAULT_SZ 5			//默认大小
#define DEFAULT_INC 3			//默认扩容大小

typedef struct SeqList
{
	SLDataType* data;
	int sz;
	int capable;
}SeqList;

在这里插入图片描述

用define定义数据可以方便修改

顺序表操作函数介绍

  1. void SLInit(SeqList* SL); 顺序表初始化
  2. void SLprint(SeqList* SL); 打印顺序表
  3. void SLPushFront(SeqList* SL, SLDataType x); 顺序表投插
  4. void SLPushBack(SeqList* SL, SLDataType x); 顺序表尾插
  5. void SLPopFront(SeqList* SL); 顺序表头删
  6. void SLPopBack(SeqList* SL); 顺序表尾删
  7. void SLInsert(SeqList* SL, int pos, SLDataType x); ~指定位置插入
  8. void SLEarse(SeqList* SL, int pos); 指定位置删除
  9. int SLFind(SeqList* SL, SLDataType x); 查找指定数据下标
  10. void SLModify(SeqList* SL, int pos, SLDataType x); 修改指定位置数据
  11. void SLDestroy(SeqList* SL); 清楚数据包

为了代码方便阅读，讲顺序表操作函数全部放在Seqlist.c文件中，将头文件放在SeqList.h，测试文件test.c 🌞

顺序表操作函数实现

实现顺序：

为了方便调试，建议每写完1-2个函数就进行测试，初始化之后，首先实现print函数可以方便我们进行调试，建议按照顺序，插入-》打印-》查找-》删除-》销毁顺序表函数。

顺序表的初始化：

void SLInit(SeqList* SL)
{
	assert(SL);				//assert防止传进来的指针为空，进行断言
	SL->capable = DEFAULT_SZ;
	SL->sz = 0;
	int* ptr = malloc(sizeof(int) * DEFAULT_SZ);	//为顺序表开辟一段空间
	if (ptr == NULL)								//预防开辟失败进行判断
	{
		perror("malloc:");
	}
	SL->data = ptr;
	printf("初始化成功\n");
}

必须先进性初始化，给顺序表开辟一个堆空间，并对其默认长度与默认最大长度进行初始化。

顺序表插入函数：

头插

头插从第一个位置插入，其余函数按顺序向后移动一格，

  • 既然有插入就一定会有空间不够用的问题，这里用到检查空间是否够用的一个函数
void CheckSL(SeqList* SL)
{
	assert(SL);	//assert防止传进来的指针为空，进行断言
	if (SL->sz == SL->capable)		//如果当前大小等于当前最大大小那么进行扩容
	{
		int* ptr = NULL;
		ptr = (int*)realloc(SL->data, sizeof(int) * (SL->capable + DEFAULT_INC));
		if (ptr == NULL)
		{
			perror("check:realloc:");
		}
		SL->data = ptr;
		SL->capable += DEFAULT_INC;
		printf("扩容成功\n");
	}
}

头插函数

  • 将所有数据向后移动，注意要从后面开始移动，不然数据会被覆盖掉

在这里插入图片描述

void SLPushFront(SeqList* SL, SLDataType x)
{
	assert(SL);	//assert防止传进来的指针为空，进行断言
	CheckSL(SL);
	int end = SL->sz - 1;
	while (end >= 0)		//将所有数据向后移动，注意要从后面开始移动，不然数据会被覆盖掉
	{
		SL->data[end + 1] = SL->data[end];
		end--;
	}
	SL->data[0] = x;		//所有数据都向后移动之后进行头插
	SL->sz++;				//当前大小+1
}

尾插

从最后进行插入数据

  • 尾插也会用到检查空间是否够用的函数，这里不重复了
void SLPushBack(SeqList* SL,SLDataType x)
{
	assert(SL);	//assert防止传进来的指针为空，进行断言
	CheckSL(SL);			//判断空间是否够用，够用直接将数据放在尾部即可
	SL->data[SL->sz] = x;
	SL->sz++;				//插入之后当前大小+1
}

指定位置插入

  • 只要有插入，就要检查空间是否够用
void SLInsert(SeqList* SL,int pos,SLDataType x)
{
	assert(SL);	//assert防止传进来的指针为空，进行断言
	assert(pos >= 0 && pos < SL->sz);
    CheckSL(SL);
	int end = SL->sz - 1;
	while (end >=pos-1)			//讲数据从后向后移动，避免被覆盖
	{
		SL->data[end + 1] = SL->data[end];
		end--;
	}
	SL->data[pos-1] = x;
	SL->sz++;			//插入之后当前大小+1
}

顺序表打印函数

写完插入立马写打印，方便进行调试

void SLprint(SeqList* SL)
{
	assert(SL);	//assert防止传进来的指针为空，进行断言
	for (int i = 0; i < SL->sz; i++)
	{
		printf("%d ", SL->data[i]);
	}
	printf("\n");
}

查找顺序表数据

int SLFind(SeqList* SL, SLDataType x)
{
	assert(SL);	//assert防止传进来的指针为空，进行断言
	for (int i = 0; i < SL->sz; i++)
	{
		if (SL->data[i] == x)
		{
			return i;
		}
	}
	return -1;
}

顺序表删除函数

头删

从头部删除数据，删除之后后面的数据依次向前移动一位，要从前往后移动，不然会被覆盖（同头插）

void SLPopFront(SeqList* SL)
{
	assert(SL);	//assert防止传进来的指针为空，进行断言
	if (SL->sz <= 0)
	{
		printf("表为空，无需删除");
		return;
	}
	int start = 0;
	while (start < SL->sz - 1)
	{
		SL->data[start] = SL->data[start + 1];
		start++;
	}
	SL->sz--;
}

尾删

void SLPopBack(SeqList* SL)
{
	assert(SL);	//assert防止传进来的指针为空，进行断言
	if (SL->sz <= 0)
	{
		printf("表为空，无需删除");
		return;
	}
	SL->sz--;
}

指定位置删除

后面的数据依次向前移动

void SLEarse(SeqList* SL,int pos)
{
	assert(SL);	//assert防止传进来的指针为空，进行断言
	assert(pos >= 0 && pos < SL->sz);
	int start = pos-1;
	while (start < SL->sz - 1)
	{
		SL->data[start] = SL->data[start + 1];
		start++;
	}
	SL->sz--;
}

修改顺序表

void SLModify(SeqList* SL, int pos, SLDataType x)
{
	assert(SL);	//assert防止传进来的指针为空，进行断言
	assert(pos >= 0 && pos < SL->sz);
	SL->data[pos - 1] = x;
}

销毁顺序表

void SLDestroy(SeqList* SL)
{
	assert(SL);	//assert防止传进来的指针为空，进行断言
	free(SL->data);//释放堆空间数据
	SL->data = NULL;//将指针置空预防野指针
	SL->sz = 0;
	SL->capable = 0;
}

文件分类

🌞🌞为了使代码更有阅读性，我们不建议把所有函数写在一个文件里，所以这里分成三个文件，模块化管理

test.c

测试文件

#include "SeqList.h"

void test(SeqList* SL)
{
	SLPushBack(SL, 10);
	SLPushBack(SL, 11);
	SLPushBack(SL, 11);
	SLPushBack(SL, 11);
	SLPushBack(SL, 11);
	SLPushBack(SL, 11);
	SLPushBack(SL, 11);
	SLPushBack(SL, 11);
	SLPushBack(SL, 19);
	SLprint(SL);

	SLPushFront(SL, 12);
	SLPushFront(SL, 13);
	SLPushFront(SL, 14);
	SLprint(SL);

	SLPopBack(SL);
	SLprint(SL);

	SLPopFront(SL);
	SLprint(SL);

	SLInsert(SL, 5, 99);
	SLprint(SL);

	SLModify(SL, 5, 22);
	SLprint(SL);

	//SLEarse(SL, 5);
	//SLprint(SL);

	SLFind(SL,5);
	SLDestroy(SL);

}
int main()
{
	SeqList SL;
	SLInit(&SL);
	test(&SL);
}

SeqList.c

i将所有函数封装在此文件下

#include "SeqList.h"

void SLInit(SeqList* SL)
{
	assert(SL);
	SL->capable = DEFAULT_SZ;
	SL->sz = 0;
	int* ptr = malloc(sizeof(int) * DEFAULT_SZ);
	if (ptr == NULL)
	{
		perror("malloc:");
	}
	SL->data = ptr;
	printf("初始化成功\n");
}

void SLprint(SeqList* SL)
{
	assert(SL);
	for (int i = 0; i < SL->sz; i++)
	{
		printf("%d ", SL->data[i]);
	}
	printf("\n");
}

void CheckSL(SeqList* SL)
{
	assert(SL);
	if (SL->sz == SL->capable)
	{
		int* ptr = NULL;
		ptr = (int*)realloc(SL->data, sizeof(int) * (SL->capable + DEFAULT_INC));
		if (ptr == NULL)
		{
			perror("check:realloc:");
		}
		SL->data = ptr;
		SL->capable += DEFAULT_INC;
		printf("扩容成功\n");
	}
}

void SLPushBack(SeqList* SL,SLDataType x)
{
	assert(SL);
	CheckSL(SL);
	SL->data[SL->sz] = x;
	SL->sz++;
}

void SLPushFront(SeqList* SL, SLDataType x)
{
	assert(SL);
	CheckSL(SL);
	int end = SL->sz - 1;
	while (end >= 0)
	{
		SL->data[end + 1] = SL->data[end];
		end--;
	}
	SL->data[0] = x;
	SL->sz++;
}

void SLPopBack(SeqList* SL)
{
	assert(SL);
	if (SL->sz <= 0)
	{
		printf("表为空，无需删除");
		return;
	}
	SL->sz--;
}

void SLPopFront(SeqList* SL)
{
	assert(SL);
	if (SL->sz <= 0)
	{
		printf("表为空，无需删除");
		return;
	}
	int start = 0;
	while (start < SL->sz - 1)
	{
		SL->data[start] = SL->data[start + 1];
		start++;
	}
	SL->sz--;
}

void SLInsert(SeqList* SL,int pos,SLDataType x)
{
	assert(SL);
	assert(pos >= 0 && pos < SL->sz);
	int end = SL->sz - 1;
	while (end >=pos-1)
	{
		SL->data[end + 1] = SL->data[end];
		end--;
	}
	SL->data[pos-1] = x;
	SL->sz++;
}

void SLEarse(SeqList* SL,int pos)
{
	assert(SL);
	assert(pos >= 0 && pos < SL->sz);
	int start = pos-1;
	while (start < SL->sz - 1)
	{
		SL->data[start] = SL->data[start + 1];
		start++;
	}
	SL->sz--;
}

void SLDestroy(SeqList* SL)
{
	assert(SL);
	free(SL->data);
	SL->data = NULL;
	SL->sz = 0;
	SL->capable = 0;
}

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

void SLModify(SeqList* SL, int pos, SLDataType x)
{
	assert(SL);
	assert(pos >= 0 && pos < SL->sz);
	SL->data[pos - 1] = x;
}

SeqList.h

将主程序所需要的函数全部在头文件中声明，增加代码阅读性

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

#define SLDataType int
#define DEFAULT_SZ 5
#define DEFAULT_INC 3

typedef struct SeqList
{
	SLDataType* data;
	int sz;
	int capable;
}SeqList;

void SLInit(SeqList* SL);
void SLprint(SeqList* SL);
void SLPushFront(SeqList* SL, SLDataType x);
void SLPushBack(SeqList* SL, SLDataType x);
void SLPopFront(SeqList* SL);
void SLPopBack(SeqList* SL);
void SLInsert(SeqList* SL, int pos, SLDataType x);
void SLEarse(SeqList* SL, int pos);
int SLFind(SeqList* SL, SLDataType x);
void SLModify(SeqList* SL, int pos, SLDataType x);
void SLDestroy(SeqList* SL);

撒花

这就是实现顺序表的全部内容了，创作不易，还请各位小伙伴多多点赞👍关注收藏⭐，以后也会更新各种关于c语言，数据结构的博客，撒花！

悲伤的猪大肠9
关注
专栏目录
数据结构线性表——顺序表、链表
qq_64105689的博客
05-14 699
1.线性表 线性表(linear list)是有n个相同特性的元素组成的有限序列，在逻辑上是线性结构，也就是连续的一条直线；但是在物理结构上，不一定是连续的。 常见的线性表有： 顺序表、链表、栈、队列、字符串.... 2.顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的数据结构，一般采用数组存储，在数组上完成增删查改。 顺序表一般分为： 1.静态的顺序表：使用定长数组存储元素。 define N 6 typedef int SeqListDataType; t.
数据结构——线性表之顺序表
weixin_68153081的博客
09-04 1928
数据结构——线性表之顺序表
数据结构实验——顺序表
02-12
一、实验目的 1、掌握用Visual C++6.0上机调试顺序表的基本方法 2、掌握顺序表的基本操作，插入、删除、查找等算法的实现 二、实验内容 1、顺序表基本操作的实现 [问题描述] 当我们要在顺序表的第i个位置上插入一个元素时，必须先将顺序表中第i个元素之后的所有元素依次后移一个位置，以便腾空一个位置，再把新元素插入到该位置。若是欲删除第i个元素时，也必须把第i个元素之后的所有元素前移一个位置。 [基本要求] 要求生成顺序表时，可以键盘上读取元素，用顺序存储结构实现存储。
数据结构试验 顺序表
weixin_46283740的博客
10-26 346
实验题目 顺序表的实现 实验内容 实现一个顺序表（包括常用基本操作）。测试顺序表。 实验要求 独立完成、严禁抄袭、参考别人的需要注明出处。提供实验代码、测试情况、遇到的问题是如何解决的。 #include <iostream> #include <cstdio> using namespace std; template<class T> class SqList { public: SqList(int cap
【数据结构实验】顺序表
PWrose的博客
10-25 502
数据结构实验，顺序表，C语言，顺序表基本算法
【数据结构】顺序表实验
qq_45857607的博客
10-24 1627
线性表：零个或多个数据元素的有限序列。 线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。 1、掌握顺序表中元素的前驱、后续的概念。 顺序表的前驱与后继指的是当前元素前一个元素与后一个元素分别是什么。如图所示，a[i-1]与a[i+1]分别是a[i]的前驱与后继。 2、掌握顺序表的建立、插入元素、删除表中某元素的操作。 //测试程序样例： #include <stdio.h> #include <stdlib.h> #define OK 1.
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
### 数据结构C++ 线性表——顺序表和单链表基本操作 #### 一、概述 在《数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx》文档中，作者详细介绍了如何在C++中实现顺序表和单链表的基本操作，并...
线性表——顺序表PPT学习教案.pptx
10-04
线性表——顺序表PPT学习教案 线性表是一种典型的线性结构，其基本特点是线性表中的数据元素是有序且是有限的。线性表可以分为顺序表和链表两种存储结构，今天我们主要讨论顺序表。 1. 线性表的定义 线性表是具有...
数据结构线性表——顺序表（2）
weixin_45735044的博客
09-27 712
1)编写算法，在一非递减的顺序表L中，删除所有值相等的多余元素。要求时间复杂度为O(n),空间复杂度为O(1); (2)实现顺序表的就地逆置算法，即在原表的存储空间将线性表（a1,a2,a3,…,an）逆置为（an,an-1,an-2,…,a1）。 问题代码 #include<stdio.h> #include<stdlib.h> #define maxsize 100 typedef struct{ int a[maxsize]; int last; }seqlis
数据结构实验1-顺序表
12-04
1、给定数组：{10，23，4，8，57，9，6，25，90，67 }，按照数据递增的方式实现排序程序。 2、已知数组结点有正有负，使负值结点位于数组的前面部分，正值结点位于数组的后面部分。
数据结构顺序表实验
linxibo's CSDN
09-19 1838
顺序表实验
数据结构实验：链表
qq_51071687的博客
10-24 1287
数据结构实验：链表实验目的实验内容和要求函数接口定义测试程序样例输出样例代码运行结果截屏图 实验目的 1、掌握链表中元素的前驱、后续的概念。 2、掌握链表的建立、插入元素、删除表中某元素的操作。 3、对链表相应算法的时间复杂度进行分析。 4、理解链表数据结构的特点（优缺点）。 实验内容和要求 要求实现链表的操作集。其中 函数接口定义 void CreateList_L(LinkList &length,int n);//创建链表 void ListTraverse(LinkList &L);
数据结构实验——顺序表操作
g332273438的博客
05-17 2694
数据结构实验C++代码实现
数据结构实验报告顺序表c语言,【数据结构】顺序表实验报告.doc
weixin_28721917的博客
05-18 1392
【数据结构】顺序表实验报告《数据结构B》实验报告系 专业 2008级 01 __班姓名 学号 2010年1 0月 9日上机题目： 顺序表的实验详细设计#define MAXSIZE 100#include#includetypedef int Elemtype;typedef struct{Elemtype data[MAXSIZE];int length...
数据结构-顺序表
最新发布
m0_74408955的博客
04-01 420
顺序表可以分为：静态顺序表与动态顺序表此顺序表采用的是动态定义的方法，我们需要将初始化中自己创建在堆上的动态空间传给指针变量a、用a访问空间存储所需数据，而size就代表我们所存储数据的个数，capacity表示顺序表的动态空间大小；最上面的宏定义表示初始化容量设定，typedef定义的类型表示所存数据类型。
数据结构实验+顺序表的基本操作
互联网小队
03-07 1211
顺序表的基本操作 #include <stdio.h> //1-1存储结构 #define MAXSIZE 100 typedef struct { int *elem; //存储空间的基地址 int length; }SqList; //1-2初始化顺序表并放入n个数据 void InitList(SqList &L) { L.elem =new int[MAXSIZE]; L.length=0; } //1-3初始化顺序表并放入n个数据 void ListIn
顺序表函数
weixin_43664746的博客
12-07 607
#include "Seq.h" #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; //创建顺序表 Seq* Create() { Seq *s = (Seq*)malloc(sizeof(Seq)/sizeof(char)); if (NULL == s) return NULL; // 给顺序表分配空间 s-&gt;pDat...
顺序表的函数操作
ewqrdsadw的博客
11-16 338
有关顺序表的函数操作这里写代码片 #include<iostream> using namespace std; int findMin(int * x,int m); void changeMin(int *x,int m); void deleteX(int *x,int m); void deleteDX(int *x,int m); int main() { cout << "创建一
数据结构实验：线性表操作与实现——顺序表与链表
"该文档是关于浙江理工大学数据结构实验，主要关注线性表的操作与实现。实验分为两部分，一是顺序表的操作，包括创建、查找、插入和删除，以及顺序表的反转；二是链表的操作，同样涉及创建、输出、反转等。实验要求...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值