1.【数据结构】—攻克顺序表（详解）

秃头的懒羊羊

已于 2023-10-22 15:36:37 修改

阅读量121

点赞数 3

文章标签：数据结构 c语言开发语言

于 2023-10-22 15:33:07 首次发布

本文链接：https://blog.csdn.net/ll620623/article/details/133973217

版权

文章目录

1.攻克线性表之一>(顺序表)详

1.攻克线性表之一>(顺序表)详

1.开启探索时刻

既然要探索，那必定要有“力量”咱们先吃饭！！！！！！！！

数据结构分为线性表和非线性表，今天我们要学习的就是顺序表，它就是线性表中的一个小类。那么，何为线性表：线性表是指n个具有相同性质的数据元素的有限序列，（可能现在看起来难以理解，但是等我们把顺序表和单链表这俩哥们学完，咱们就明白这句话的含义了。）
并且线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

（友情提醒：学习数据结构之内的知识最重要的是画图！画图！在画图！所以关于数据结构我最多的就是俩个字看图！看图！看图！）

这次的重点便是顺序表！！！！！！！！

2.概念及其结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。（可以简单理解为就是数组的高级应用）

如下图直观表达:

其次顺序表分为：静态顺序表和动态顺序表

1.静态顺序表：使用定长数组存储元素。( 空间开多了浪费，开少了不够用 )

2.动态顺序表：使用动态开辟的数组存储。(按需申请)

静态顺序表只适用于确定知道需要存多少数据的场景。不适用于现实生活中的实际情况，所以接下来我们只讲解动态顺序表。

好啦，大家准备好了嘛，现在开始探索了！！！

3.探索开始（内容）

顺序表的实现我们分这为三个文件

SeqList.h ：用于引用的头文件、顺序表的定义以及函数的声明。

SeqList.c：用于函数的定义与实现。

test.c：用于顺序表功能的测试。

我们的思想是，既然有初始化那就有销毁，然后还涉及空间内存，那么就要释放内存，也就是顺序表的销毁，然后还会有空间不够的情况，所以就会有空间的扩容，这便是一个大概的主体，里面的细节咱就慢慢在这个主体中实现。先把插入数据写出来，然后测试再写其他。

到最后我们要完成的就是这样几个函数（接口）：

void SLInit(SL* psl);     //初始化 
void SLDestroy(SL* psl);  //顺序表销毁
void SLPushFront(SL* psl , SLDatatype x);    //头插
void SLPushBack(SL* psl , SLDatatype x);    //尾插
void SLPopFront(SL* psl);    //头删
void SLPopBack(SL* psl);  //尾删
void SLPrint(SL* psl);  //数据打印，用于查看数据
void SLCheckCapacity(SL* psl);    ///检查顺序表长度，若满或空就开始增容
int SLFind(SL* psl, SLDatatype x);  //在顺序表中寻找元素,有就返回下表，没有返回-1
void SLInsert(SL* psl,int pos, SLDatatype X);    //在指定的位置插入元素
void SLModity(SL* psl, int pos, SLDatatype X);     //在指定的位置删除元素
void SLModity(SL* psl, int pos, SLDatatype X);//修改指定位置元素

1.顺序表的定义

在咱们的SeqList.h 中展开如下内容

#pragma once//使同一个文件不会被包含(include)多次,不必担心宏名冲突。
 
//先将可能使用到的头文件写上
#include<stdio.h>
#include<stdlib.h>
#include <string.h>
#include<assert.h>//在任何能够接触或者试者指针、内存和文件操作这些地方，
//为了防止一些不易发现的bug咱们就要用assert来断言，避免坏事的发生。


typedef int SLDataType;//顺序表的类型名称，给变量定义一个易于记忆且有明确意义的新名字，
//并且便于以后存储其它类型时方便改动.
//（比如我晚点想存double类型的数据，我就直接将 int 改为 double ）
 
typedef struct SeqList
{
	SLDataType* a;//指向动态开辟的数组。
	size_t size;//有效数据个数
	size_t capacity;//空间容量
}SL;
//struct 关键字和 SeqList 一起构成了这个结构类型。
//typedef 为这个结构起了一个重新起了个名字（别名），叫 SL，后续的创建结构体变量就是SL XXX，就不会那么繁琐
//同 int 和 double 那样直接使用 SL 定义变量。

看图

依据我们上面创建的结构体，再结合图，理解起来因该就简单多了。

2.顺序表的初始化

在 SeqList.c 下

但是不要忘了申明，在 SeqList.h中，这里均是函数的实现所以后面我不会提示在 SeqList.c 下

void SLInit(SL* psl)//在这里我们传地址而不是传值，因为形参是实参的拷贝，形参的改变不影响实参。
{
	assert(psl);//断言
     //用malloc申请了一块空间
	psl->a = (SLDatatype*)malloc(sizeof(SLDatatype)*4);
    //解读：malloc申请开辟 sizeof(int)乘以4 即16个字节大小的空间后，强制类型转换成(int*)
    
	if (psl->a == NULL)///如果开辟失败
	{
		perror("malloc fail");//输出错误信息
		return;
	}
	psl->capacity = 4;//初始化的时候先开辟一点空间
	psl->size = 0;
}

如果对malloc不熟悉的可以自行动手了解一下，自己动手丰衣足食，还可以把realloc也看一下，下面我们会用上。

3.顺序表的扩容

为了避免友友们综合错误，我在这里说一下，扩容、销毁和打印者三个均在 SeqList.c 下

//判断是否扩容,若是，则扩
void SLCheckCapacity(SL* psl)
{
    //判断是否需要扩容
	if (psl->size == psl->capacity)//若最后一个数据的下一个位置的下标等于空间容量，则需扩容，
 //觉得有点绕的话就结合尾插那个地方看看
	{
        //多人容易把下面这一行代码写成
        //SLDataType*tmp=(SLDataType*)realloc(ps->a,ps->capacity*2);这只扩到8个字节
		SLDatatype* tmp = (SLDatatype*)realloc(psl->a, sizeof(SLDatatype) * psl->capacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		psl->a = tmp;//a接收realloc返回的指针，realloc不一定原地扩容，可能原地、异地
	   //如果没加上面那行代码程序没有报错，只是巧合，刚好原地扩容了。
        //原地就是后面的空间足够
        //异地就是后面不够，然后把数组拷贝放到另外一个够的地方
		psl->capacity *= 2;//如果扩容成功,size不变,capacity容量是原来2倍

	}
}

4.顺序表的销毁

避免了出现因为动态内存分配的野指针。

void SLDestroy(SL* psl)
{
	assert(psl);//断言
	free(psl->a);//释放空间内存
	psl->a = NULL;//制空
	psl->capacity = 0;
	psl->size = 0;

}

5.顺序表的打印

把增删查改的数据打印出来，这里我们传的是结构体指针，还有传递本身的版本，但是太麻烦，直接用指针访问更简单。



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

6.顺序表的尾插

oid SLPushBack(SL* psl, SLDatatype x)//尾插
{
	assert(psl);//断言
	//第一种
	SLCheckCapacity(psl);//扩容函数
	psl->a[psl->size++] = x;
    
    //第二种
    //SLCheckCapacity(psl);
	//psl->a[psl->size] = x;
    //psl->size++；
    
	//第三种
    //这是我们后面的指定插入函数，其实写到最后，很多地方都可以复用了。
	//SLInsert(psl, psl->size , x);
    
    //这里有我一给错误可以借鉴一下，我就是把size弄成了size-1就出现了数据错乱
    //尾插我这里内存出错就是size-1了，导致内存中数据错乱，要在所有数据后插入，不是在最后一个插入
}

大家用那个方法都可以。

结合图看：我们尾插的地方就是x，其实就是指向了数组最后一个的下一个的下标，如红色箭头。

到这里我们就可以小小的实现一下尾插后续的大家可以自己动手实验，这样收获更多

如图：

说一下，我们这里调试就用多个test函数来，这样又方便又快捷。

7.顺序表的头插

相比较于尾插，头插就麻烦一点，因为我们要挪动数据，到底是从前往后挪动，还是从后往前挪动哩，答案是从后往前，因为如果从前往后的话，那么我们数组里面的值就被覆盖还了，从而发生错误，那么有了这个想法我们先看图！（下文代码的end+1==图中的size）

顺序表头插1
顺序表头插2
顺序表头插3
顺序表头插4

void SLPushFront(SL* psl, SLDatatype x)//头插
{

	assert(psl);
    
	SLCheckCapacity(psl);
	int end = psl->size - 1;//用end表示了数组最后一个元素
	//挪动数据
	while (end >= 0)
        //我起初的错误1：没有 = 就会指向不属于自己的空间。越界访问了
	{
		psl->a[end + 1] = psl->a[end];//把前一个元素给后一个，
		end--;		
	}
	psl->a[0] = x;
	psl->size++;
    
    //SLInsert(psl, 0, x);  这个是复用指定插入函数

}

8.顺序表的尾删

void SLPopBack(SL* psl)//尾删
{
	assert(psl);
    
    //psl->a[psl->size-1] = 0;  为什么我们不赋值操作把最后一个赋值0，-1，或者什么什么，
    //要是你那个位置刚好是你要赋值的就冲突了，并且完全没有意义，所以我们不采用
    
	//assert(psl->size > 0);也可以这样断言，
	psl->size--;//这里假如size为0了呢，其实不用担心，因为我们的断言的这个指针要是为0，
    //那就会直接暴力检查，让你的程序运行不下去报错。

	//SLErast(psl,0);指定删除的复用
}

看图：

顺序表尾插1
顺序表尾插2

如果疑惑4为什么还在数组上点击这个脚标¹

9.顺序表的头删

在这里我们是不是又要挪动数据，这次的挪动就正好和插入相反，这里时从前往后挪动依次进行覆盖就行了。

先看图！

顺序表头删1
顺序表头删2
顺序表头删3

void SLPopFront(SL* psl)//头删
{
	assert(psl);

	assert(psl->size > 0);
	int start = 1;//起始位置
	while (start < psl->size) //这里又俩种写法我这是一种还有一直种方法
	//start=0；/start < psl->size-1，这俩这大家可以思考一下，有什么区别，相当于一个自主思考小问题。
	{
		psl->a[start - 1] = psl->a[start];
		start++;
	}
	psl->size--;
    
    //SLErast(psl, psl->size - 1);复用指定删除
}

10.顺序表的指定插入

在指定位置插入数据，那我们就要挪动要插入那个位置以后的数据。（pos是要插入数据的位置）

看图！

在这里插入图片描述

void SLInsert(SL* psl, int pos, SLDatatype x)//插入
{
	assert(psl);

	assert(pos >= 0 && pos <= psl->size);//限制了只能在这个区间以内
    
	SLCheckCapacity(psl);//插入数据不管三七二十一就是先扩容，不然容量不够就不好了。
	int end = psl->size - 1;
	while (end >= pos)
	{
		psl->a[end + 1] = psl->a[end];
		end--;
	}
	psl->a[pos] = x;
	psl->size++;
}

11.顺序表的指定删除

这里的pos指的是被删除的数，下面是一整个流程。

看图！

在这里插入图片描述

这里如果还在疑惑，那么就同尾删哪里有相应的解释转脚标¹

void SLErast(SL* psl, int pos)//删除
{
	assert(psl);

	//assert(pos >= 0 && pos < psl->size);//这里少了等号是因为删除只能删有数据的
	//而数据始终是size-1，所以不能等于，不然可能出现内存问题   //上面那个断言间接的就帮你检查了。
	
	int begin= pos;
	while (begin < psl->size-1)
	{
		psl->a[begin] = psl->a[begin+ 1];
		begin++;
	}
	psl->size--;

}

12.顺序表的查找

如果找到了就返回下标，没有找到就返回-1.

int SLFind(SL* psl, SLDatatype x)//查找 有下标，无返-1
{
	assert(psl);

	for (int i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

13.顺序表的指定修改位置的值

void SLModify(SL* psl, int pos, SLDatatype x)//修改
{
	assert(psl);
	assert(pos >= 0 && pos < psl->size);
	psl->a[pos] = x;
}

最后的俩个接口（函数）都很简单，可以配合我们上面的各个接口（函数）来愉快的玩耍！！

4.探索完成，回家吃饭咯！

这些总和起来就是一个完整的顺序表，至于我为什么没有把总的源码放上来，我想，大家既然是要学习，如果我直接把总代码给你了，你一个Ctrl+c一个Ctrl+v完事了，然后自己就觉得自己很厉害，“学会了”也学废了，所以希望大家认真理解了，再回过头综合我这里的代码，那简直是如履平地。（杜绝做CV工程师、CV程序员，但是这段话对于真正的大佬来说，可能有点冒犯，先致歉）但是咱们普通人就==老老实实的学，踏踏实实的干就可以了！！！！加油！！！正在努力的那个你！！！！==

最后的俩个接口（函数）都很简单，可以配合我们上面的各个接口（函数）来愉快的玩耍！！

4.探索完成，回家吃饭咯！

这些总和起来就是一个完整的顺序表，至于我为什么没有把总的源码放上来，我想，大家既然是要学习，如果我直接把总代码给你了，你一个Ctrl+c一个Ctrl+v完事了，然后自己就觉得自己很厉害，“学会了”也学废了，所以希望大家认真理解了，再回过头综合我这里的代码，那简直是如履平地。（杜绝做CV工程师、CV程序员，但是这段话对于真正的大佬来说，可能有点冒犯，先致歉）但是咱们普通人就老老实实的学，踏踏实实的干就可以了！！！！加油！！！正在努力的那个你！！！！

这次的探险结束咯，探险者你有收获没有？！！！

这样的话我们就相当于把最后一个元素给删除了，有人就会说，你者明明还在数组里面啊，怎么会哩，这不影响吗，其实是不会影响的，因为我们做的尾插操作是赋值，所以4这个位置再被使用时就会被重新赋值，不影响！！ ↩︎ ↩︎

秃头的懒羊羊

关注

3
点赞
踩
4

收藏

觉得还不错? 一键收藏
1
评论
1.【数据结构】—攻克顺序表（详解）

既然要探索，那必定要有“力量”咱们先吃饭！！！！！！！！数据结构分为线性表和非线性表，今天我们要学习的就是顺序表，它就是线性表中的一个小类。那么，何为线性表：线性表是指n个具有相同性质的数据元素的有限序列，（可能现在看起来难以理解，但是等我们把顺序表和单链表这俩哥们学完，咱们就明白这句话的含义了。）并且线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。（友情提醒：学习数据结构之内的知识最重要的是画图！画图！在画图）
复制链接

扫一扫