基础顺序表

已于 2024-08-24 12:35:32 修改
阅读量952 收藏 14
点赞数 34
文章标签： c语言 数据结构
于 2024-04-05 15:18:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80328577/article/details/137397644
版权

顺序表分类

        顺序表分为动态顺序表和静态顺序表，他们的基本结构是怎么展现的呢？

#define N 100
//静态顺序表
struct Seqlist
{
	int arr[N];//存放数组大小
	int size;//有效存储数据个数
};

        静态顺序表只有两个成员，首先是存放数据数组，其次我们还要知道有效的数据个数,其存放数据大小是一开始便已经确定的，并不灵活!

再看动态顺序表

struct Seqlist
{
	int* arr;//存放数组大小
	int size;//有效存储数据个数
	int capacity;//开辟空间大小
};

        为啥这里是int* ？当然是因为我们需要动态开辟内存空间，既然是动态，当然要用到动态内存管理的知识 ，让我们的arr依据存储数据size需求量，对数组空间进行扩容或缩容。这里多了一个capacity表示开辟空间的大小。为啥要这样设计，因为有效存储数据size的大小并不一定等于空间capacity的大小，这点我们接下来就会明白。

        其实动态和静态都能解决问题，可是对于静态顺序表来说，一开始我们也不知道到底需要存储多少数据，就像抖音的老板一样，他也不知道自己的产品需要存储多少用户信息。万一初始N给小了，就放不了太多，容易导致数据丢失；万一初始N给大了，会占用很大的内存空间！

        因此，对比动态和静态顺序表，我们可以清楚的知道动态顺序表更有优势，接下来就是实现一个简单的动态顺序表。

动态顺序表的具体实现

初始化

        初始化其实很简单，用一个封装函数，让arr指针为空，size和capacity都为0。也可以用malloc初始扩充一定的空间，不多赘述。

void Seqlist_Init(SL* ps)
{
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

        这里改良一下，将int重定义位SLDataType是为了以后方便修改数据

        万一我们以后要存储字符串咋办，很多涉及到int这个关键字的地方肯定不能全用VS的替换吧，当然不可能啊，以后代码万一增多，手动修改出现错误或误操作，代码可能直接崩溃，这是很可怕的事情。

        同时为了避免每次传结构体都要加上struct，把它重新命名为SL，这样会很方便！

        那我初始化函数这样写对不对？

        相信你们判断得没错，当然是不对的，我们渴望修改结构体里的数据，从而初始化。根据函数调用中实参和形参的关系可知，形参只是形参的临时拷贝，改变形参不会改变实参，所以传值调用是不合法的（建议可以了解一下函数栈帧的知识），对于用函数交换两个变量，我们是不是只能传两个变量的地址啊，这里也一样。

typedef int SLDataType;
typedef struct Seqlist
{
	
	SLDataType* arr;//存放数组大小
	int size;//有效存储数据个数
	int capacity;//开辟空间的大小
}SL;

这样写是不是没有问题了，我们经过调试，发现初始化成功了。

也可用malloc初始化先开辟小块空间，这里就不再赘述。

销毁

        有初始化必然就有销毁！销毁就必然要将开辟的内存空间重新还给操作系统，并将size和capacity置0。

void Seqlist_Destroy(SL* ps)
{
	if (ps->arr) //等价于  if(ps->arr != NULL)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

        这里不要忘了将arr手动置NULL。为啥啊？我们用free函数将内存释放只是失去了访问之前开辟空间的能力，首地址还是那个地址没有变，可是已经没有明确的指向，构成野指针，而且free不会自动置空。

        补充一点，例如return 返回值，我们调用一个函数来返回一个结果，我们是不是一般都是返回一个值啊，万一返回一个地址咋办，而且这个地址是正常的吗？

以一道题目为例：

char* GetMemory()
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}

        可以运行吗？

抱歉，编译器直接报错。原因嘛和上面一样啊，这个p地址还是那个地址，但是GetMemory函数执行完后p指向的空间还给操作系统了，没有访问权限，就会指向不明确，所以p为野指针，不能正确执行程序。就算有些编译器可以成功运行此程序，那也是非法访问。

插入数据

        有很多种插入方法，我们以头插和尾插为例：

尾插

        

//尾插
void SLPushBack(SL* ps, SLDataType x)//x为插入数据
{
	assert(ps);
	SLCheckOut(ps);
	ps->arr[ps->size++] = x;
}

        直接这样写行不行？试想，万一capacity和size相等，即空间大小等于有效个数大小，是不是没有空间了，需要扩容。还有如果capacity为0，arr的地址是无效的哦，也不能插入数据吧！

        因此需要写个判断函数：

void SLCheckOut(SL* ps)
{	
	if (ps->capacity == ps->size)
	{
		int NEWCapacity = (!ps->capacity) ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, NEWCapacity * sizeof(SLDataType));
		//空间开辟失败
		if (!tmp)
		{
			perror("realloc");
			exit(1);
		}
		//空间开辟成功
		ps->arr = tmp;
		ps->capacity = NEWCapacity;
	}
}

注意：

1、capacity == size怎么办？说明此时需要先扩容再插入数据。

2、capacity为0怎么办？所以要单独先判断capacity，为0就给个初始空间为4（随便给，别太离谱），不为0，扩容两倍。

3、realloc万一开辟失败怎么办？需要报错，来终止程序,开辟内存成功后，才能进行插入数据操作。因为一旦realloc开辟失败，不光不能解决问题，同时还有极大可能把我原来的数据删掉，这不是帮倒忙吗，因此我们使用realloc必须考虑这一点。

4、万一ps接收到空指针怎么办？那就无法实现插入数据，因此要用assert断言一下（可以去网上找一下assert的用法）其他插入删除数据同理

5、"exit(1)":只是一个简单的退出程序语句。

6、size表示有效数据个数，其初始值为0，所以插入完要++，因为是后置++，在插入数据前不会影响，也可以分开写，无所谓。

 我们测试一下：

插入成功。

头插

老规矩还是先整个图，方便理解：

看到这里是不是就明白了：

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckOut(ps);
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//最终arr[1] = arr[0]
	}
	ps->arr[0] = x;
	ps->size++;
}

测试一下：

测试成功！

打印数据

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

        是不是很简单。

        还记得刚才在头插中ps->size为啥要加啊,其实与尾插一样，既然你插入了一个数据，那么对于有效数据size来说，肯定要增加1才符合逻辑。

无“ps->size++”：

有“ps->size++”：

删除数据

        显然对应前面插入数据有尾删和头删两种情况。

尾删

        

据图知：

void SLPopBack(SL* ps)
{
	assert(ps);
	ps->size--;
}

下面是测试结果：

注意：

1、不需要考虑arr里面的数据是啥，所以我们只需要打印有效数据就可以。并不需要对要删除的数据做处理。

2、还是要断言一下，如果ps为空指针，删除就无意义了。

头删

据图知：

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

注意：

1、assert(ps->size)是判断顺序表是否为空，要是size为0，虽然打印有一个数据，但是此时无效数据为0。

下面是测试：

任意位置的插删数据

插入

        因此，就是要将pos位之后的数据像右移动一位，再把要放入的数据赋值给数组第pos位，最后有效数据个数加一

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	for (int i = ps->size; i >= pos + 1; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//ps->arr[pos + 1] = ps->arr[pos]
	}
	ps->arr[pos] = x;
	ps->size++;
}

那我们还是测试一下：

由此可知，头插尾插也是这种特殊情况。

删除

据图知，将pos位之后的数据向前移动，移动位置不在pos位前，最后有效数据个数减一。

//任意位置删除
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	SLCheckOut(ps);
	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];//ps->arr[ps->size - 2] = ps->arr[ps->size - 1]
	}
	ps->size--;
}

测试一下：

注意：

1、用assert断言pos，让pos在安全且合法的范围内。

2、插入数据时，可以把数据插入到下标size上，而删除数据时，不能删除下标size-1后面的数据。

 还是用图来说明一下：

相信看完这个图，你就会明白了。

查找

//查找
int FindSL(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			//找到了
			return i;
		}
	}
	//没有找到
	return -1;
}

        这里我用下标i来遍历数组中的元素，如果找到数据返回下标，如果没找到返回-1，其中-1是随便给的数，目的是为了与数组下标区分开。

补充

        关于扩容的规则，可以参考一下这篇博客，扩容规则的推导涉及到概率论的知识，作者还不会。

http://t.csdnimg.cn/BGiZa

总结

        顺序表的本质就是对一个数组增删查改，顺序表是属于线性表的一种。顺序表物理和逻辑结构都是线性的，而线性表不同的地方是其只在物理结构是非线性，逻辑结构依然是线性的！

源码

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "sqlist.h"
//测试顺序表
void test()
{
	//声明一下结构体
	SL sl;
	/*初始化*/
	Seqlist_Init(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	PrintSeqlist(&sl);
	SLInsert(&sl, 0, 9);
	SLInsert(&sl, 2, 8);
	//SLPushFront(&sl, 5);
	//SLPushFront(&sl, 6);
	//SLPushFront(&sl, 7);
	//SLPopBack(&sl);//尾删
	//SLPopFront(&sl);//头删
	SLInsert(&sl, sl.size, 7);
	PrintSeqlist(&sl);

	SLErase(&sl, 2, 8);
	SLErase(&sl, 0, 9);	
	SLErase(&sl, sl.size - 1, 7);
	PrintSeqlist(&sl);
	/*销毁*/
	Seqlist_Destroy(&sl);
	printf("\n");
	int ret = FindSL(&sl, 4);
	if (ret < 0)
	{
		printf("没找到");
	}
	else
	{
		printf("找到啦");
	}
}
int main()
{
	test();
	return 0;
}

sqlist.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "sqlist.h"

void Seqlist_Init(SL* ps)
{
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}
void Seqlist_Destroy(SL* ps)
{
	if (ps->arr) //等价于  if(ps->arr != NULL)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}
void SLCheckOut(SL* ps)
{	
	if (ps->capacity == ps->size)
	{
		int NEWCapacity = (!ps->capacity) ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, NEWCapacity * sizeof(SLDataType));
		//空间开辟失败
		if (!tmp)
		{
			perror("realloc");
			exit(1);
		}
		//空间开辟成功
		ps->arr = tmp;
		ps->capacity = NEWCapacity;
	}
}

//尾插
void SLPushBack(SL* ps, SLDataType x)//x为插入数据
{
	assert(ps);
	SLCheckOut(ps);
	ps->arr[ps->size++] = x;
}
//头插
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckOut(ps);
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//最终arr[1] = arr[0]
	}
	ps->arr[0] = x;
	ps->size++;
}
//打印
void PrintSeqlist(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}
//尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	ps->size--;
}
//头删
void SLPopFront(SL* ps)
{
	assert(ps);
	//判断顺序表是否为空
	assert(ps->size);
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
//任意位置插入
void SLInsert(SL* ps, int pos)
{
	assert(ps);
	//不能让顺序表为空
	assert(pos >= 0 && pos <= ps->size);
	SLCheckOut(ps);
	for (int i = ps->size; i >= pos + 1; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//ps->arr[pos + 1] = ps->arr[pos]
	}
	ps->arr[pos] = x;
	ps->size++;
}
//任意位置删除
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	SLCheckOut(ps);
	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
//查找
int FindSL(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			//找到了
			return i;
		}
	}
	//没有找到
	return -1;
}

sqlist.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//#define N 100
静态顺序表
//struct Seqlist
//{
//	int arr[N];//存放数组大小
//	int size;//有效存储数据个数
//};

//动态顺序表
typedef int SLDataType;
typedef struct Seqlist
{
	
	SLDataType* arr;//存放数组大小
	int size;//有效存储数据个数
	int capacity;//开辟空间的大小
}SL;

//初始化
void Seqlist_Init(SL* ps);

//销毁
void Seqlist_Destroy(SL* ps);
//打印
void PrintSeqlist(SL* ps);
//头部插入 / 尾部插入
void SLPushBack(SL* ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x);
//头部删除 / 尾部删除
void SLPopBack(SL* ps);
void SLPopFront(SL* ps);
//任意位置插入
void SLInsert(SL* ps, int pos, SLDataType x);
//任意位置删除
void SLErase(SL* ps, int pos, SLDataType x);
//查找
int FindSL(SL* ps, SLDataType x);

chilli q
关注
  • 34
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
顺序表
Outtch_的博客
11-07 3780
顺序表是什么呢？ 顾名思义，顺序表是物理地址连续的存储单元依次存储数据的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。 顺序表和数组有什么区别呢? 顺序表比数组更约束，顺序表物理地址上必须连续存储，数组是顺序表在实际编程中的具体实现方式。 顺序表分为静态顺序表和静态顺序表（主要区别在于他们的容量是否可变） 静态顺序表 静态顺序表的概念： 顺序表的容量在静态时期（编译期间）确定，大...
什么是顺序表
kokopop007的博客
08-25 1万+
顺序表 在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。 对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种有意义的信息，或者表示数据之间的某种关系。 这样的一组序列元素的组织形式，我们可以将其抽象为...
顺序表详解
热门推荐
weixin_65132948的博客
04-24 2万+
目录 一、线性表的概念 二、顺序表 1、顺序表的概念 1）. 静态顺序表：使用定长数组存储元素。 2）. 动态顺序表：使用动态开辟的数组存储。 三、接口实现 1、创建 2、初始化 3、扩容 4、尾插 5、打印 6、销毁 7、尾删 越界： 8、头插 9、头删 10、任意位置插入 11、删除任意位置 12、查找 13、修改 一、线性表的概念 【百度百科】 线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是...
实验一 顺序表
popoywei的博客
11-01 1232
实验一
C实现顺序表
鸽子的博客
08-04 3344
1. 实验目的 （1）掌握线性表的顺序存储结构； （2）验证顺序表及其基本操作的实现； （3）理解算法与程序的关系，能够将顺序表算法转换为对应的程序。 2. 实验内容 （1）建立含有若干个元素的顺序表； （2）对已建立的顺序表实现插入、删除、查找等基本操作。 3. 实验提示 定义顺序表的数据类型——顺序表结构体SeqList，在SeqList基础上实现题目要求的插入...
Java实现顺序表
weixin_64448174的博客
05-12 6070
目录 一、顺序表的简单理解 1、为什么我们要以数组为基础来构建顺序表呢？ 2、顺序表都具有哪些功能 二、顺序表的代码实现 1、构建并且初始化顺序表 2、在顺序表中添加元素 1、判断需要添加元素的下标是否在顺序表的范围内 2、如果添加元素下标合法，进行添加元素操作。 3、判断顺序表是否满了满了的话我们需要进行扩容 4、实现代码如下： 3、打印顺序表中的元素 4、判断顺序表中是否含有某个元素 5、查找顺序表中元素的下标 6、更新顺序表对应下标的元素值 7、查找顺序表对应下标的元
数据结构-顺序表与链表详解
m0_62918577的博客
11-05 1858
顺序表概念及分类，以及动态顺序表的接口实现 链表的概念及结构以及无头单向非循环链表的接口实现 在不同方面解析顺序表和链表的区别
顺序表实现
m0_73736626的博客
07-12 1898
顺序表是用来连续存放数据单元的一种结构，逻辑连续的两个元素在实际上也为连续的。
顺序表的查找
m0_63341217的博客
10-17 2171
顺序表查找，顺序表特点，顺序表优缺点
c语言顺序表指针,从顺序表的算法看指针的妙用
weixin_33037813的博客
05-19 1769
从顺序表的算法看指针的妙用By 祥泰科学的发现往往是偶然的，我在研究算法的时候，发现了C语言指针的另类用法，技巧令人拍案叫绝，欲知详情，请看下文。首先，先看一下下面的这段代码：//定义顺序表的元素类型。应根据需要修改typedef int DataType;struct SeqList{intMAXNUM；//顺序表中最大元素的个数intn;//存放线性表中元素的个数n≤MAXNUMDa...
大学生基础顺序表算法库
09-22
《大学生基础顺序表算法库详解》 在计算机科学的学习中，数据结构与算法是不可或缺的基础，其中顺序表作为最基础的数据结构之一，是理解和掌握其他复杂数据结构的基石。本篇将深入探讨“大学生基础顺序表算法库”的...
C语言_线性表之顺序表
01-16
线性表是最基础的数据结构之一，顺序表则是线性表的一种常见实现。本文将深入探讨C语言实现顺序表的相关知识点，包括其定义、操作以及具体实现。 顺序表是一种特殊的线性表，它的所有元素在内存中是连续存放的，...
数据结构上机_顺序表基本操作_数据结构基础_
09-29
在本课题中，我们将深入探讨"数据结构上机_顺序表基本操作_数据结构基础_"这一主题，这涉及到一系列在顺序表上的基本操作，包括初始化、输出、插入、删除、计算长度、逆置、排序以及合并有序顺序表等。 顺序表是一...
顺序表测试1_WordforWord_用顺序表实现词频统计_
10-03
顺序表是一种基础的数据结构，它将元素存储在一个连续的内存区域中，通过索引来访问元素，具有简单直观的操作方式。 首先，我们需要理解顺序表的基本概念。顺序表可以看作是一个动态数组，它的优点在于插入和删除...
线性表之顺序表
03-28
线性表是计算机科学中一种基础且重要的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。...理解并掌握顺序表的概念及其操作，对于学习更复杂的数据结构如栈、队列、树等有着基础性的帮助。
UEFI——使用标准C库
qq_44807736的博客
09-06 472
C标准库是ANSL C标准为C语言定义的标准库。C标准库包含15个头文件：assert.h ctype.h error.h float.h limits.h locale.h math.h setjmp.h signal.h stdarg.h stddef.h stdio.h stdlib.h string.h time.h。使用C标准库开发的应用程序有很强的可移植性，标准库为上层应用程序屏蔽了底层平台的差异，使得这些程序可以在任意平台上通过编译。当我们决定在工程中使用标准库函数的时候，有两种方法。
C和指针：字符串
暮色年华的博客
09-07 915
字符串就是一串零个或多个字符，并且以一个位模式为全0的NUL字节结尾。字符串长度就是字符串中字符数。string为指针常量(const修饰string)，指向的string是常量不能修改。size_t是无符号数，定义在stddef.h。C语言遍历字符串: while(*string++!='\0'){}上面两句不等价，第二个恒真，无符合数-无符合数还是无符合数，恒大于0。
c语言和c++的区别
最新发布
2301_77743184的博客
09-07 3739
.........
【最新华为OD机试E卷-支持在线评测】计算疫情扩散时间(200分)多语言题解-(Python/C/JavaScript/Java/Cpp)
春秋招笔试突围
09-06 394
🍭 大家好这里是，一枚热爱算法的程序员✨ 本系列打算持续跟新的三语言AC题解💻 ACM金牌🏅️团队| 多次AK大厂笔试 ｜ 编程一对一辅导。
线性表详解：顺序表与链表
1. 顺序存储：也称为顺序表，它将线性表的所有元素存储在一块连续的内存区域中。通过数组的方式，可以通过下标直接访问元素，具有较高的存取效率。例如，"0，1，2，…，9" 或 "A，B，C，…，Z" 可以看作是顺序表的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值