数据结构顺序表（一篇基本掌握）

已于 2023-08-16 16:05:28 修改
阅读量1k 收藏 30
点赞数 33
分类专栏： 数据结构 文章标签： 数据结构
于 2023-06-16 14:26:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZYK069/article/details/130030497
版权

绪论

        从本章开始就是开始数据结构的开端，本章将会写出数据结构中的顺序表的代码实现，多会以注释的方法来描述一些细节（注释是我们程序员必须常用的工具）。

     18245ee000ef4f1bae3d771a162ce48c.webp

 

话不多说安全带系好，发车啦（建议电脑观看）。

附：红色，部分为重点部分；蓝颜色为需要记忆的部分（不是死记硬背哈，多敲）；黑色加粗或者其余颜色为次重点；黑色为描述需要

目录

1.线性表

2.顺序表

2.1顺序表的结构：

2.1.1 顺序表的初始化：

2.1.2 顺序表的摧毁

2.1.3 顺序表的放入数据

2.1.4 顺序表的删除数据

2.1.5 打印顺序表的数据       

2.2顺序表的源代码：

1.线性表

知识点：

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串..

细节（注意点）：

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组（地址连续）和链式结构（地址不连续）的形式存储。

2.顺序表

知识点：

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储（本质就是一个数组只不过用结构体包装了一下）。8d76a2ecaea34521a40fdbe3ce9ac402.png

顺序表分为：静态顺序表（实现开辟好数组的空间大小）以及动态顺序表（用动态内存管理的方式来进行内存管理）

细节：

我们要实现一个顺序表的话首先我们要知道顺序表的框架：

  1. 顺序表的结构体
    1. 数组（a）
    2. 顺序表中的元素个数（size）
    3. 容量（用于动态顺序表，是动态申请的大小，用于和元素个数比较判断申请空间是否足够）
  2. 有了这个结构后，我们就需要实现一个顺序表的基本功能
    1. 将数据放进顺序表中
    2. 将顺序表中的数据删除
    3. 初始化顺序表（主要针对于动态开辟空间提前申请空间）
    4. 归还（摧毁）所借的空间
    5. 将顺序表中的数据打印出来

下面这要讲的是动态的顺序表、如果需要静态的将结构体中的容量去掉，再把数组改一下即可（若有问题的话可以评论我都会看），我们就把顺序表想成一个数组就能很好的理解了

2.1顺序表的结构：

顺序表所要的结构是由数组、元素个数、容量组成的

代码实现如下：

typedef struct SeqList//将结构体名称重命名为
{
	SLDataType* a;//开辟SLDataType（用typedef重定义类型名，这样方便与改变结构体内的数据类型）类型的空间
//数组的本质是指针所以为了更方便理解就直接写成指针的形式SLDataType* a 
	int size;//元素个数
	int capacity;//容量
}SeqList;//重命名为SeqList 这样方便后面使用
//宏定义如下：
//#define SLDataType int 
//使用结构体类型
//SeqList s;即可
//不用写成 struct SeqList s;

2.1.1 顺序表的初始化：

将容量capacity和个数size进行简单的初始化，主要是申请一片空间来给a来存数据

代码如下：

void InitSeqList(SeqList* obj)//将结构体用指针接收
{
	assert(obj);
	obj->capacity = INIT_CAPACITY;//通过指针来访问结构体中的成员，将capacity先初始化为INIT_CAPACITY（用宏来确定capacity的起始大小，这样方便后改变）
	obj->size = 0;//0个成员
	obj->a = (SLDataType*)malloc(sizeof(SLDataType) * obj->capacity);//malloc动态申请结构体大小的capacity个空间
	if (obj->a == NULL)//判断一下是否申请成功
	{
		perror("malloc");//如果失败就报错
		return;
	}
}

//宏
//#define INIT_CAPACITY 4 （这是应该定义在头文件中的）

//调用的方法
//SeqList s;（应该定义在测试test.c文件中）
//InitSeqList(&s);

//而一般的结构的实现又是放在SeqList.c的文件中，这样来进行分源管理

2.1.2 顺序表的摧毁

顺序表的摧毁主要是为了将向操作系统借的空间归还，以及再将容量和元素个数归为0

void DestorySeqList(SeqList* obj)//指针接收结构
{
	assert(obj);//判断结构是否为空,防止访问到NULL指针（这是一个好习惯）
	free(obj->a);//直接释放所借用的空间
	obj->a = NULL;//再将其置为NULL
	obj->capacity = obj->size = 0;//将容量和个都置为0,摧毁了自然就没了
}

//调用方法
//SeqList s;
//DestorySeqList(&s);

2.1.3 顺序表的放入数据

1.从尾部插入数据

尾部插入就比较的简单了，因为顺序表其实是一个数组所以直接在最后位置插入数据就行（此时最后位置的下标就是元素个数）。

 

void SeqListBackPush(SeqList* obj, SLDataType x)//将结构体用指针接收通过指针来找到成员，x是所要尾插的数据
{
	assert(obj);//判断结构体是否为NULL

	If_Add_Capacity(obj);//判断数据是否已经把所借的容量填满了

	obj->a[(obj->size)++] = x;//在a的最后位置插入数据，可以发现其实size个数就是最后位置的下标
}

但要注意判断容量是否满足，如果容量已经是满的了（size == capacity）就需要扩容，If_Add_Capacity (判断是否要增容)

void If_Add_Capacity(SeqList* obj)
{
	if (obj->size == obj->capacity)//判断已有成员个数是否等于容量,若等则进去
	{
		SLDataType* ptr = (SLDataType*)realloc(obj->a, sizeof(SLDataType) * obj->capacity * 2);//进来后就说明空间不够了，需要开空间
		//一般多直接开辟比容量大两倍的空间 即 对a开辟结构体大小为原capacity两倍的空间
		if (ptr == NULL)//判断是否申请成功
		{
			perror("realloc");//不成功则报错

			return;
		}
		obj->a = ptr;//因为可能是异地扩容所以还要将ptr赋值给数组a
		obj->capacity *= 2;//容量 乘于 2
		ptr = NULL;//无用的指针置为NULL（好习惯）
	}
}

2.从头部插入

在一个数组中若想从头部插入 你就需要把数据先全部往后挪动一位，再将这个数据存放到第一个位置处。

void SeqListFrontPush(SeqList* obj, SLDataType x)
{
	assert(obj);//判空

	If_Add_Capacity(obj);//判是否满了
	for (int i = obj->size; i > 0; i--)//将所有数据往后移一位
	{
		obj->a[i] = obj->a[i - 1];//此处只要是未满的就能直接就行移位并不会有事
	}
	obj->a[0] = x;//在a[0]位置处添加数据
	obj->size++;//元素个数++,这可别忘了！
}

3.指定位置插入

在满足pos位置是一个正常的位置的前提下,并且同样需要判断是否要扩容， 要在某个位置处插入，其本质其实和头插有些类似，需要把插的位置后的数据全部往后挪一位后，最后再在那个位置插入数据即可。


void SeqListInsert(SeqList* obj, int pos, SLDataType x)//在pos位置处添加数据
{
	assert(obj);//判空
	pos -= 1;//换成下标
	assert(pos >= 0 && pos <= obj->size);//判断这个位置是否有问题
	If_Add_Capacity(obj);//判断是否满了
	int i = obj->size;//和头插的方法几乎一样
	for (i; i > pos; i--)//将从位置处开始的数据全部往后挪一位
	{
		obj->a[i] = obj->a[i - 1];//从尾部开始防止覆盖
	}
	obj->a[i] = x;//在位置处插入数据
	obj->size++;//size++ 别忘了！
}

2.1.4 顺序表的删除数据

1. 从尾部删除

在删除之前我们需要判断一下是否还有数据在顺序表中（assert(obj->size > 0)）,对于一个数组来说我们删除时直接对元素个数进行 - - 即可并不会去真正的删除，当下一次插入数据时就直接覆盖了，也不会有什么影响。

void SeqListBackPop(SeqList* obj)
{
	assert(obj);//判空
	assert(obj->size > 0);//为真就过、为假就会报错,若没有数据那就是有问题的

	obj->size--;//此处的尾删并不直接将空间归还，而仅仅只是把元素个数-1这样

	//就不会访问到，即使后面需要再次添加数据也就直接覆盖了,因为要归还空间的成本太高了
}

2.从头部删除

同样我们需要先判断一下顺序表中是否还有数据、对于头部删除来说直接将第一个数据覆盖了就好 。

void SeqListFrontPop(SeqList* obj)
{
	assert(obj);//判空
	assert(obj->size > 0);//判断是否有数据
	for (int i = 0; i < obj->size - 1; i++)//直接从第2个位置开始往前覆盖掉即可
	{
		obj->a[i] = obj->a[i + 1];
	}
	obj->size--;//注意要 - - 
}

3.指定位置删除

判断pos是否在顺序表中、最后将从pos+1位置开始数据覆盖即可。

void SeqListErase(SeqList* obj, int pos)
{
	assert(obj);//判空
	assert(obj->size > 0);//是否有数据

	pos -= 1;//换成下标
	assert(pos >= 0 && pos <= obj->size);//是否符合要求

	for (int i = pos; i < obj->size - 1; i++)//和头删对应此处就应该是从pos+1位置处开始往前覆盖
	{
		obj->a[i] = obj->a[i + 1];//将pos位置处先覆盖 , 然后以此往后
	}
	obj->size--;//注意 - -
}

2.1.5 打印顺序表的数据       

就和数组的打印一样，直接遍历打印即可

void SeqListPirnt(SeqList* obj)//指针接收结构体
{
	assert(obj);//判空
	for (int i = 0; i < obj->size; i++)//从下标为0的位置处开始往后遍历
	{
		printf("%d ", obj->a[i]);//结构体访问成员：*obj表示结构体 在 .访问 就还能写成 （*obj）.a[i] 这两个是等价的一般喜欢用前面方法
	}
	printf("\n");//换行
}

如果有任何问题，欢迎讨论！

2.2顺序表的源代码：

我将全部放在一个里面对于分源内容请自行分开，或者直接合并也行（合并方法将声明以及包含自身的头文件去掉即可直接使用）

//SeqList.h
#pragma once

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


#define INIT_CAPACITY 4
//sequence

typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* a;
	int size;
	int capacity;
}SeqList;

void InitSeqList(SeqList * obj);
void DestorySeqList(SeqList* obj);

void SeqListBackPush(SeqList* obj,SLDataType x );

void SeqListBackPop(SeqList* obj);

void SeqListPirnt(SeqList* obj);

void SeqListFrontPush(SeqList* obj, SLDataType x);

void SeqListFrontPop(SeqList* obj);

void SeqListInsert(SeqList* obj, int pos, SLDataType x);

void SeqListErase(SeqList* obj, int pos);

//SeqList.c

 #define _CRT_SECURE_NO_WARNINGS 1

#include"SeqLIst.h"
//sequence 顺序

void If_Add_Capacity(SeqList* obj)
{
	if (obj->size == obj->capacity)
	{
		SLDataType* ptr = (SLDataType*)realloc(obj->a, sizeof(SLDataType) * obj->capacity * 2);
		if (ptr == NULL)
		{
			perror("realloc");

			return;
		}
		obj->a = ptr;
		obj->capacity *= 2;
		ptr = NULL;
	}
	return;
}

void InitSeqList(SeqList* obj)
{
	assert(obj);

	obj->capacity = INIT_CAPACITY;
	obj->size = 0;
	obj->a = (SLDataType*)malloc(sizeof(SLDataType) * obj->capacity);
	if (obj->a == NULL)
	{
		perror("malloc");
		return;
	}
}

void DestorySeqList(SeqList* obj)
{
	assert(obj);

	free(obj->a);
	obj->a = NULL;
	obj->capacity = obj->size = 0;
}

void SeqListBackPush(SeqList* obj, SLDataType x)
{
	assert(obj);
	
	If_Add_Capacity(obj);

	obj->a[(obj->size)++] = x;

}

void SeqListBackPop(SeqList* obj)
{
	assert(obj);
	assert(obj->size > 0);//为真就过、为假就会报错
	
	obj->size--;
}

void SeqListPirnt(SeqList* obj) 
{
	assert(obj);
	for (int i = 0; i < obj->size; i++)
	{
		printf("%d ", obj->a[i]);
	}
	printf("\n");
}


void SeqListFrontPush(SeqList* obj, SLDataType x)
{
	assert(obj);

	If_Add_Capacity(obj);
	for (int i = obj->size; i > 0; i--)
	{
		obj->a[i] = obj->a[i - 1];
	}
	obj->a[0] = x;
	obj->size++;
}

void SeqListFrontPop(SeqList* obj)
{
	assert(obj);
	assert(obj->size > 0);
	for (int i = 0; i < obj->size - 1; i++)
	{
		obj->a[i] = obj->a[i + 1];
	}
	obj->size--;
}

void SeqListInsert(SeqList* obj, int pos, SLDataType x)
{
	assert(obj);
	pos -= 1;//换成下标
	assert(pos >= 0 && pos <= obj->size);
	If_Add_Capacity(obj);
	int i = obj->size;
	for (i; i > pos; i--)//从最后开始将填充数据
	{
		obj->a[i] = obj->a[i - 1];
	}
	obj->a[i] = x;
	obj->size++;
}

void SeqListErase(SeqList* obj, int pos)
{
	assert(obj);
	assert(obj->size > 0);

	pos -= 1;//换成下标
	assert(pos >= 0 && pos <= obj->size);

	for (int i = pos; i < obj->size - 1; i++)
	{
		obj->a[i] = obj->a[i + 1];
	}
	obj->size--;

}

//test.c
//测试是否能用

 #define _CRT_SECURE_NO_WARNINGS 1

#include"SeqLIst.h"

int main()
{
	SeqList s;
	InitSeqList(&s);
	SeqListPush(&s, 1);
	SeqListPush(&s, 2);
	SeqListPush(&s, 3);
	SeqListPush(&s, 4);
	SeqListPush(&s, 5);

	SeqListPop(&s);
	SeqListPop(&s);
	SeqListPop(&s);

	SeqListFrontPush(&s, 0);

	SeqListFrontPush(&s, -1);

	SeqListInsert(&s, 1, 3);
	SeqListErase(&s, 2);
	SeqListPirnt(&s);

	DestorySeqList(&s);

	return 0;
}

分源管理时的头文件 ：

8994d578871a4a6690a9a8eaea2f7f4e.png

 

 

持续更新大量数据结构细致内容,三连关注哈

 

 

 

溟洵
关注
  • 33
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 57
    评论
专栏目录
数据结构之顺序表
weixin_45893046的博客
10-07 211
顺序表Tips①形参 实参 &②typedef 和 define的区别：③return代码 Tips ①形参 实参 & 所有改变顺序表的函数的形参都是SqList &L ,不改变顺序表的函数的形参都是SqList L 形参SqList &L 改变顺序表后,能让实参也发生改变 形参SqList L 不能让实参也发生改变 详细原因可见c++学习 ②typedef 和 define的区别： 1.typedef 仅限于为类型定义符号名称。 typedef int
数据结构顺序表
weixin_45913083的博客
11-03 129
本代码用c语言完成，实现以下操作 建立顺序表 输出顺序表 插入元素 删除元素 按值查找 顺序表的逆置 #include<stdio.h> #include<stdlib.h> #define MAXSIZE 100 typedef struct{ int data[MAXSIZE]; int length; }SqList; void menu(){ //显示菜单 printf("菜单\n"); printf("\t1.输出\n"); printf("
【数据结构】Java实现顺序表，附完整代码
最新发布
xiaochuan_bsj的博客
08-04 892
Java实现顺序表，附完整代码
数据结构-顺序表
weixin_42112184的博客
10-11 450
一、构造一个顺序表： #include <stdio.h> #include <stdlib.h> typedef struct Vector{ int size,length; int *data; }Vector; void init(Vector *vector,int size){ vector->size = size; vector->length = 0; vector->data = (int *)malloc(sizeof(int)
数据结构与算法-顺序表（链表篇）
09-09
总之，理解和熟练掌握链表这一数据结构对于任何IT专业人士来说都是至关重要的，无论你是从事软件开发、数据处理还是系统设计。深入学习并实践链表，将有助于你在面对复杂问题时能够设计出更高效、更灵活的解决方案。
数据结构从入门到精通-顺序表
03-02
在所有数据结构中，顺序表是最基础的一种，适用于初学者理解和掌握。本篇文章将深入探讨顺序表的概念、实现、操作以及其在C语言中的应用。 顺序表是一种线性数据结构，它的特点是元素在内存中按顺序连续存储。每个...
顺序表的基本操作 一篇文章快速了解！
09-14
总之，理解和掌握顺序表的基本操作是学习数据结构的基础，也是提高编程能力的关键。通过熟练运用顺序表，我们可以更好地设计和优化算法，解决各种实际问题。在后续的学习中，你还可以探索如何通过其他数据结构（如...
顺序表的建立参考代码
05-10
数据结构（C语言）中常见算法实现代码： 1.顺序表的建立
数据结构与算法（一）顺序表的实现
07-04
但作为初学者，理解和掌握顺序表的基本操作是至关重要的，它是学习更复杂数据结构和算法的基础。 总的来说，顺序表是数据结构学习的起点，其增删改查的操作虽然看似简单，却蕴含了数组、指针、动态扩容等基本概念，...
【数据结构】顺序表
East-sunrise的博客
08-15 4356
顺序表带你走进数据结构世界🎈
顺序表的结构
weixin_41939072的博客
04-07 226
#ifndef SeqList_H#define SeqList_Hconst int MaxSize=10;class SeqList{public:       SeqList(){length=0;}       SeqList(int a[],int n);       ~SeqList(){}       void Insert(int i,int x);       int Delet...
第二章顺序表框架图
Zhengqunwu的专栏
12-29 519
C语言顺序表框架 （增删改查）
SunNang的博客
11-11 271
/* Note:Your choice is C IDE */ #include "stdio.h" //1、先确定顺序表容量 #define MAX 20//宏定义顺序表最大存储量 //2、定义顺序表结构体 typedef struct { //数组存放数据 int data[MAX]; //长度，记录当前数组里元素个数 int len; }list;//typedef：起别名 int i;//循环变量 //输入 void shuru(list *s,int n) { for(i=0;.
线性表之顺序表框架实现与测试
m0_46300070的博客
04-14 423
#ifndef DYNAMIC_ARR_H #define DYNAMIC_ARR_H #include<stdio.h> #include<stdlib.h> #include<string.h> //实现动态增长，所以我们把它放在堆上 typedef struct DYNAMIN_ARRay { int* addres;//存放数据的地址 int size;...
线性表顺序存储设计与实现_框架搭建
1
01-20 351
传智扫地僧课程学习笔记。 这里是要写一个测试框架， 用于测试所写的链表的操作，是否正确， 本来是要测试dll动态库的，可是我这里没有， 所以只好自己写个实现，其实只有函数名，内部的函数实现，是空的， 设计到3个文件，seqlist.h，seqlist.c，以及我们自己写的主文件 #include #include #include #include "seqlist.
顺序表：数据结构入门与操作实战
线性表是数据结构中最基本的概念之一，它是一系列具有特定关系的数据元素的集合。本篇内容聚焦于顺序表，这是线性表的一种常见存储结构，它通过连续的内存空间来存储元素，允许直接访问任一位置，效率高，适合用于...
评论 57
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

溟洵

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

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

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

打赏作者

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

抵扣说明：

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

余额充值