一个新手自学的旅途——数据结构——顺序表（1）

D.evil175

于 2024-09-17 15:25:30 发布

阅读量510

点赞数 14

文章标签：数据结构

本文链接：https://blog.csdn.net/2403_87343336/article/details/142309400

版权

什么叫做数据结构？

数据结构是由数据和结构两部分组成，是计算机用于存储，组织数据的一种方式。

自诉：

而学习计算机，对于数据的存储，利用或者保护等等，是非常重要的，如果不重视，可能会在日后工作中因为粗心大意，或者学艺不精而丢失自己的工作，甚至告别社会一段时间......导致在代码的行业少一位精英份子。因此，学好数据结构是非常有必要的一件事，对于编程行业，那么本篇章将尽本人的能力，以一个初学者的视角为大家呈现一份数据结构学习的心得体会，才艺不精，博得贵人一笑小生便心满意足。最后非常欢迎大佬们在评论区指导纠正小生的错误。

前言：学习数据结构前一定要学习扎实一门语言，例如c/c++，Java，python等等，小生的数据结构相关文章皆由c语言创作，同时小生做一个建议，使用c语言去学习数据结构，并且，c语言中的结构体和动态内存分配务必要知道。

数据结构的组成（通常包含以下三部分）：

1.数据的逻辑结构

什么叫逻辑结构？说白了就是数据本身的东西，跟计算机存储没啥关系。

2.数据的物理结构

什么叫物理结构？这个就是数据在计算机里面的存储表示。

3.数据的操作

定义在数据结构上可以进行的操作。其实就是增删查改这一系列能方便我们管理数据的行为。本节关于线性表中的顺序表具体实现请看下文。

顺序表的理解

1.数组是最基本的数据结构

因为数组本身就可以完成数据的增删查改，所谓顺序表，不过是更为高级一点的，方便程序员使用的存储结构。举个例子，两家不一样的餐馆，一家五星级酒店，一家普通烟火家常饭店馆。同样能炒土豆丝，但是五星级炒的不叫土豆丝，往往是更加华丽的名字（小生没吃过，不知道）。只是在普通的基础上增加了一些摆放特色，提高例如色觉的感受，但这往往会提高食客的用餐体验。

这就是顺序表的一种理解，它只是在数组的基础上增加了一些新的方法。

2.顺序表是线性表的一种——具有相同特性的数据的集合

顺序表的特性

物理结构，逻辑结构一定是连续的（数组是物理，逻辑双连续，所以可以说顺序表也是双连续）

顺序表的分类

主要分为两种

1.静态顺序表

struct SeqList
{
 int arr[1000];
 int size;//顺序表当前有效的数据个数
 };

2.动态顺序表

struct SeqList
{
 int * arr;
 int size;//用它来进行计算有效个数
 int capacity;//总空间个数
 };

既然顺序表有两种方法，是不是两种便捷程度都相同？

当然不是！

首先说说静态顺序表：

我们在学习c语言这门基础入门语言的时候，使用vs（visual studio）的朋友们可能面临一个困难，就是无法直接创建变长数组，请看下面代码：

int main()
{
	int a;
	scanf("%d", &a);
	int arr[a];//尝试用vs以这种方式直接创建变长数组，导致vs报错
	return 0;
}

当然Linux环境下gcc编译器朋友们没有体会这样的痛苦。

当我们做到具有未知量的题目，而又恰巧需要创建一个数组，在所学知识不全的情况下，我们往往会直接创建一个比较大的数组，例如int arr[1000];

这样会有什么问题？空间开辟未知。

如果开辟过大，那么会导致内存泄露过大；

如果开辟过小，会导致无法完整存储数据（后果相当严重）。

而这一数组初始化问题其实就是我们顺序表中静态顺序表的问题。因此我们基本不会使用它进行数据存储。

那么动态顺序表又怎么一回事呢？

顾名思义，顺序表是一个动态的。什么动态？空间的动态，意味着我们创建的存储结构可以伸缩变化，那怎么做到呢？

在c语言中我们已经学习了一个知识，叫做动态内存分配的知识。里面有这样几个函数，帮助我们主动向系统索要开辟内存空间的权限：

malloc /calloc/realloc/free

简单回顾一下：

（1） malloc：void* malloc (size_t size);//返回一个地址，报错则返回一个NULL指针。

（2） calloc：作用和malloc一样，但它会初始化被开辟地址的值为0。

（3） realloc：void* realloc (void* ptr, size_t size);//输入一个地址给函数，并提供所需开辟空间的大小。值得注意的是，realloc的开辟空间的有三种情况：直接在紧接着后方开辟。如果在原有地址后方连接开辟新空间，但是空间不够，则会重新将所有空间（包括主动申请开辟的）转移到新的连续地址。如果空间都不够则丢失原有地址和原有值，并且终止开辟空间，返回一个NULL指针。

（4） free：void free (void* ptr);//将所申请的内存空间还给系统，也就是内存释放。我们申请获得了开辟空间权限，那么也要把空间还给系统才行，如果不还给系统，会导致内存泄漏，内存使用过高，继而引发一系列问题。

那么对于上面（4）free函数内存释放，我们可以猜想一个问题，为什么我们创建变量例如int a；主动向系统申请一块空间存放4个字节的整形变量，却不使用free主动释放呢？

原因：

类似于int a;这样的空间申请，是在内存里面的栈区进行的。栈内存的分配和释放时自动的，由系统在函数调用和返回时进行

而使用malloc这样的函数主动向内存申请空间是在堆区申请。堆区内存需要我们在适当的时候使用free函数来释放这部分内存。

顺序表的增删查改

接下来实现顺序表的增删查改

项目创建：

一个头文件，一个源文件，以及一个test.c的测试文件

注意c++后缀.cpp改为.c

头文件（SquList）：用于调用库函数，存储自定义函数名和结构体创建等等，这里我们可能会用到这三个头文件包含的库函数

#pragma once

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

源文件：用于实现自定义函数。例如打印函数

//打印
void SLPrint(SL s)
{
	for (int i = 0; i < s.size; i++)
	{
		printf("%d ", s.arr[i]);
	}
	printf("\n");
}

test.c文件：调用自定义函数，测试所写代码是否成功

void SLTest01()
{
	SL sl;
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(sl);//打印的是前面已经开辟的四个空间sl
	//尾插4个数字为1 2 3 4
	//SLPushFront(&sl, 5);
	//SLPushFront(&sl, 6);
	SLPopFront(&sl);
	SLPrint(sl);
	SLPopFront(&sl);
	SLPrint(sl);
	SLDestroy(&sl);
}

int main()
{
	SLTest01();
	return 0;
}

代码实现：

1.结构体创建

#define SLDataType int//将int改换一个名字，方便以后数据类型更替

struct SeqList
{
	SLDataType* a;//存放开辟空间
	int size;//有效数据个数
	int capacity;//总空间大小个数
};
typedef struct SeqList SL;//同时定义该结构体名字为SL


//当然你也可以这样
typedef struct SeqList
{
    SLDataType* a;
    int size;
    int capacity;
}SL;

（这里可能有疑问，为什么要定义#define SLDataType int？因为在for循环里面条件栏可能会定义一个局部变量来完成for的功能，如果我直接使用编译器的替换功能，可能会把这里面的也替换掉，例如int替换为char，请看如下代码

for(int a=0;a<10;a++)

如果我替换了所有int会发生什么？int被直接替换将会导致for循环完全崩溃。所以我们需要提前为int定义一个新的名字，当然原有的int名字不受影响。）

2.希望实现顺序表功能

我们在自己创建的头文件中写入如下函数名，关于实现我们在源文件中完成

//初始化
void SLInit(SL* ps);
//销毁
void SLDestroy(SL* ps);
//扩容
void SLCheckCapacity(SL* ps);
//打印
void SLPrint(SL* ps);

//尾部插入
void SLPushBack(SL* ps, SLDataType x);
//头部插入
void SLPushFront(SL* ps, SLDataType x);

//尾部删除
void SLPopBack(SL* ps);
//头部删除
void SLPopFront(SL* ps);

如此，我们只需要调用SquList.h这一个头文件，就可以直接使用源.c中的函数

3.结构体初始化

在test.c和源.c中我们均写入#include"SquList.h"这样的代码，这是自定义头文件调用

test.c中：

void SLTest()
{
	SL sl;
	SLInit(&sl);//初始化函数使用
}
int main()
{
	SLTest();
	return 0;
}

请注意SL是数据类型，和int别无过大区别。这里创建了SL sl结构体变量

并将其地址传入SLInit()函数中

在源.c中：

//初始化函数实现
void SLInit(SL* ps)
{
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

让a的地址是一个空指针，方便后续扩容，同时将实际个数size和总个数capacity都赋值为0，因为结构体本身还没开辟空间。

4.结构体销毁

在源.c中：

void SLDestroy(SL* ps)
{
	if (ps->a)
	{
		free(ps->a);
	}
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

if条件里面ps->a，这里是判断a是否是空指针，如果是NULL（0），那么根据if条件判断规则，当为NULL时，数为0，则不执行free(ps->a)。为什么要有这样一个判断？因为如果使用free释放一个NULL指针，那么程序会直接崩溃。

然后ps->a = NULL;是因为我们将空间还给系统，但是里面的值不一定发生改变，可能还会保留之前的值，从而引发一些问题。这和malloc申请空间free释放，再接一个赋值NULL是一模一样的。

同时将capacity和size两者赋为0，时刻保持数据相统一。

5.结构体的扩容

在源.c中（以下函数实现均是在源.c中实现）：

void SLCheckCapacity(SL* ps)
{
	assert(ps);
	//
	if (ps->capacity == ps->size)//判断是否需要扩容
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = realloc(ps->a, newCapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc");
			exit(1);
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
}

顾名思义扩容是在原有基础上进行一个扩容。结构体本身是具有空间的，如果没有任何内容，或者结构体内不存在任何内容，那么这个ps将会是一个NULL指针。断言将会以一种暴力结束程序的方法避免出现这种情况。

外层 if 的条件判断是判断是否需要扩容，如果实际数据个数和总空间个数是一样的，那么就要开辟空间，来进行一个扩容。

int newCapacity 这里使用 int 而不是SLDataType的原因正是小生之前所说，此处不能被修改数据类型为char或者其他的。

后面

ps->capacity == 0 ? 4 : 2 * ps->capacity; 很典型的一个三目操作符的使用。这里需要引入一个概念：通过数学，科学家们发现了对于计算机一次空间开辟的多少最好是二的倍数或者三的倍数，避免空间过大或者过小造成同静态结构体一样的问题。

SLDataType* tmp = realloc(ps->a, newCapacity * sizeof(SLDataType));使用realloc函数申请空间，需要注意的是这里不能直接赋值给我们的ps->a，否则可能会因为realloc空间申请失败而导致将原有的空间包括值清除。

		if (tmp == NULL)
		{
			perror("realloc");
			exit(1);
		}

这里用来判断tmp是否是空指针，如果为空，则使用perror函数在终端上打印问题，并由exit退出整个程序

		ps->a = tmp;
		ps->capacity = newCapacity;

最后是将tmp所存储的已被申请空间的首地址传递给ps->a指针，再将开辟的空间个数传递给capacity。

6.打印函数的实现

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

这里比较简单，最主要就是一个for循环打印，可以直接参考代码

7.尾插（尾部插入）

void SLPushBack(SL* ps, SLDataType x)
{
	SLCheckCapacity(ps);
	ps->a[ps->size] = x;
	++ps->size;
}

首先参数有两个，一个是创建SL* ps结构体指针，另一个是向数组尾部插入的数值（这里是 int 类型，可以更改为char类型或者其他）

SLCheckCapacity函数是5中的扩容选项。因为不确定我们每次在数组尾部插入一个数据时，数组的空间是否足够，于是需要进行一次空间判定加申请。判定和申请均已在该函数中实现。

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

这里直接在 [] 里面输入ps->size，原因是，方括号里面填写的是数组下标，而数组下标从0开始，size 本身的值是为存储有效个数，将其本身填入方括号指向的便是新开辟的一个空间。将 x 赋值到尾部

++ps->size;

最后size必须加一，时刻保持size和数组有效个数同步。

8.头插（头部插入）

//头插
void SLPushFront(SL* ps, SLDataType x)
{
	SLCheckCapacity(ps);
	//平移一次
	for (int i = ps->size; i > 0; i--)
	{
		ps->a[i] = ps->a[i - 1];//i-1==size-1，开辟的空间是足够向后平移一格
	}
	ps->a[0] = x;
	ps->size++;
}

大致上和尾插一样，不过需要注意的是其中的一个循环代码。它的作用是在主动开辟好空间后，将所有的原有值往后挪动一位，再进行赋值，同时也要size++。

9.尾删（尾部删除）

//尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);
	//ps->a[ps->size - 1] = NULL;
	ps->size--;
}

首先assert(ps)不用多说。那么assert(ps->size)什么意思呢？断言一个size，如果size为0，则说明有效个数为0（存都没有存放，我为什么要删除呢？）

可以发现被注释掉的一串代码：//ps->a[ps->size - 1] = NULL; 最初我是这样想的：将size-1，就是将最后一个数字删除，用什么删除？我想的是用NULL，但是转念一想，似乎有点多此一举，甚至更加麻烦。我干脆不要用它，直接最后面来一串 ps->size--;

我来解释一下为什么：size--，意味着有效个数减少一个，那么在其他函数，例如插入函数里面，我是不是就直接把这最后一个数字“删除了”？因为我已经不可能在我所有的函数中使用到最后一个数字了，尽管他的地址里面还存放的是那个数，但是我不使用它，他不就成了一个无效的值吗？我以后函数读取这个结构体，也只是读取到size-1就结束了。所以这就是为什么我觉得多此一举了。

10.头删（头部删除）

//头删
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size);
	for (int i = 0; i <= ps->size-1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}

和尾删一样，只是多了一个for循环，对齐数组罢了。

最后：以上就是小生作为一名初学者，对结构体的一部分认识，以及对顺序表的增删查改代码的理解，在对阅览的朋友们有帮助的条件下，小生希望朋友们能点点关注点点赞，更希望且欢迎大佬们指正错误（这真的很重要！！！）。后续小生会不断出数据结构以及c++的内容，这将会是一个完整的初学者从零开始到创作游戏的一个视角。让我们共同学习，共同进步，为IT行业添砖加瓦。