【数据结构】C--顺序表1.0版本(本文非常适合小白观看,已尽力详解,以及图解也是尽量列举)

最新推荐文章于 2024-05-22 21:41:43 发布
最新推荐文章于 2024-05-22 21:41:43 发布
阅读量857 收藏 31
点赞数 29
分类专栏： C--数据结构 文章标签： 数据结构 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65186652/article/details/130779738
版权

目录

0.前言

什么是数据结构？

1.逻辑结构:

1.1线性结构:

1.2非线性结构:

        (1)集合

        (2)树形结构

        (3)图形结构或者网状结构

2.存储结构

一.线性表

二.顺序表

顺序表与数组的关系:(非常容易混淆)

1.静态顺序表：使用定长数组存储元素

2.动态顺序表：使用动态开辟的数组存储

接口实现

1️⃣ 初始化:SLInit

2️⃣销毁：SLDestroy

3️⃣检查容量:SLCheckCapacity

4️⃣顺序表打印:SLPrint

5️⃣尾部插入:SLPushBack

6️⃣头部插入:SLPushFront

7️⃣尾部删除:SLPopBack

8️⃣头部删除:SLPopFront

9️⃣中间插入:SLInsert

🔟中间删除:SLErase

1️⃣1️⃣查找:SLFind

1️⃣2️⃣修改:SLModify

 三.整体实现代码

SeqLish.h

SeqList.c

Test.c

0.前言

        本篇文章包含了不少的代码测试情况,以及经过调试之后如何找出bug的情况,也悉数列举。本篇文章虽然没有菜单,是1.0版本,日后本菜鸟的代码能力提高之后会逐步完善。但是此文章经过了本人的详细思考,以及理解情况，也可以给大佬们和朋友们列举一些反例,也希望大家可以从中吸取经验,最后希望大佬们如果乐意的话可以考虑给我留下个免费的赞,您的支持是我创作的最大动力,感谢!

在讲解这一章开始时，我先说明一下什么是数据结构。

什么是数据结构？

数据结构 (Data Structure) 是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的
数据元素的集合。
数据结构是由三部分进行组成，分别是:逻辑结构、存储结构和数据的运算

1.逻辑结构:

 这里的一般线性表就是顺序表的意思。

1.1线性结构:

1.2非线性结构:

(1)集合

集合中的数据元素除了同属一个集合外，其它是没有关系的。

(2)树形结构

 (3)图形结构或者网状结构

2.存储结构

一.线性表

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

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

二.顺序表

概念及结构

顺序表是用一段 物理地址连续 的存储单元依次存储数据元素的线性结构，一般情况下采用数组存
储。在数组上完成数据的增删查改。

顺序表与数组的关系:(非常容易混淆)

这块我简单提一下顺序表和数组的关系:

对于数组而言:

数组的元素是可以随机存放的,因为：数组通过下标访问是可以任意存储的

可以看到值已经放进去了

对于顺序表而言:

顺序表是要连续存放的是,这个连续存放,不是指的是值连续,而是空间连续(意思是你存放的时候，不能跳着存，必须从0下标开始，依次向后存放)

简单地讲:

顺序表不能随意存储,顺序表必须从0下标开始,依次向后存放,意思就是他是顺序存储的,不会出现空一个位置的情况。

顺序表一般可以分为：动态和静态顺序表,

动态顺序表:也是基于数组实现的，只不过它可以实现扩容，而数组是固定长度大小的

1.静态顺序表：使用定长数组存储元素

 图解:

定义静态顺序表:

#define N 10
typedef int SLDatatype;//这个地方可以避免写死类型是int,以后想换就换
struct SeqList
{
	SLDatatype a[N];//为了避免写死数组大小,需要改的时候到处改,那就使用宏定义
	int size;
};

 静态顺序表的缺点:

 如果存满了还想存入数据,那就不能继续存储了,因为空间是固定的

#define N 10

 N-->改成10000,如果这个地方要存储10001,那还是不够存储,如果存不满10000个空间,那会浪费空间

总体来说:给小了不够用，给多了浪费

因此：

静态顺序表 只适用于确定知道需要存多少数据的场景 。静态顺序表的定长数组导致 N定大了，空
间开多了浪费，开少了不够用 。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间
大小，所以下面我们实现动态顺序表。

2.动态顺序表：使用动态开辟的数组存储

图解:

定义动态顺序表

//动态顺序表
typedef int SLDatatype;//这个位置换成double会导致问题,可能会导致全元素都是0
typedef struct SeqList
{
	SLDatatype* a;//指向动态开辟的数组
	int size;	 //存储的有效数据的个数
	int capacity;//容量空间的大小
}SL;//类型名重定义

接口实现

1️⃣ 初始化:SLInit

void SLInit(SL* psl);//动态顺序表初始化
错误的初始化:

正确的初始化:

void SLInit(SL* psl)
{  
    //malloc扩容因为malloc类型是->void* malloc (size_t size);所以需要强制转换
	psl->a = (SLDatatype*)malloc(sizeof(SLDatatype) * 4);//开4个比较合适
	//开辟失败会返回NULL,并打印错误信息
	if (psl->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	psl->capacity = 4;//使用结构体指针指向访问对象的成员,当前容量
	psl->size = 0;//当前有效信息个数
}

 图解:

2️⃣销毁：SLDestroy

SLDestroy(SL* psl);//顺序表销毁 
void SLDestroy(SL* psl)//销毁不是整没了，而是还给操作系统了
{
	free(psl->a);//这里不free的话会产生野指针
	psl->a = NULL;
	psl->size = 0;
	psl->capacity = 0;
}

3️⃣检查容量:SLCheckCapacity

说明一下:

realloc是新增到多少空间,比如说我本来是20个int的空间，(int*)realloc(arr,40),这是把空间整体扩到40个int,不是说增了多少，后面这个40的位置是整体的大小,而不是20+40=60。

 这个realloc的知识点可以看这篇文章，比较详细地展开说明:http://t.csdn.cn/H3I26

void SLCheckCapacity(SL* psl)
{
	if (psl->size == psl->capacity)//有效信息的个数等于当前容量
	{
		SLDatatype* tmp =(SLDatatype*)realloc(psl->a, sizeof(SLDatatype) * psl->capacity * 2);
		if (tmp == NULL)//申请空间过大可能会申请失败
		{
			perror("realloc fail");
			return;
		}
		psl->a = tmp;//原地扩容用的是原来的地址，异地扩容用的是新的
		psl->capacity *= 2;//当前容量*2
	}
}

图解:

(SLDatatype*)realloc(psl->a, sizeof(SLDatatype) * psl->capacity * 2);

这个地方扩2倍是比较合适的。

4️⃣顺序表打印:SLPrint

void SLPrint(SL*psl);//顺序表打印

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

打印顺序表的每个元素

5️⃣尾部插入:SLPushBack

void SLPushBack(SL* psl, SLDatatype x); //顺序表尾插 
void SLPushBack(SL* psl, SLDatatype x)
{
	assert(psl);	
	SLCheckCapacity(psl);//容量初始值为4,检查当前容量,不够则扩容
	psl->a[psl->size++] = x;

}

调用测试尾部插入的代码:

void TestSeqList1()
{
	SL s;
	SLInit(&s);
	
	SLPushBack(&s, 1);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushFront(&s,5);
	
	SLPrint(&s);

	SLDestroy(&s);
}

 执行:

6️⃣头部插入:SLPushFront

void SLPushFront(SL* psl, SLDatatype x);//头部插入

这里要说明一下头插之后的原有数组的元素的移动情况:从后往前挪动

从后往前的意思:是从数组原本有的元素开始，从最后一个元素开始往后面的空间移动，这样整体看来，对于数组原有元素来说，相对位置上确实是后面元素先挪动到后面，前面元素紧跟着后面元素的步伐

void SLPushFront(SL* psl, SLDatatype x)
{
	assert(psl);//应对可能传过来的NULL指针，而且好处是直接告诉你哪个文件的哪一行出问题
	SLCheckCapacity(psl);

	//挪动数据
	int end = psl->size-1;
	while (end >= 0)
	{
		psl->a[end + 1] = psl->a[end];
		--end;
	}
	psl->a[0] = x;
	psl->size++;
}

代码可以看这个图解:

顺序表无元素:

这个图是头插第一个元素(顺序表无元素时候)end数组下标的位置,先把a[0]赋值，然后size此时为0++,有效元素个数+1

顺序表有元素:

这图是先从数组最后一个元素(也就是6)开始挪动，先把元素6往后面的空间挪动，不够了再扩容，然后7把6覆盖，以此类推，接着，看x此时输入(1)的是什么元素，再把a[0]赋值，达到头插的效果

调用头部插入的测试代码:

void TestSeqList2()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushFront(&s, 5);
	SLPushFront(&s, 6);
	SLPrint(&s);

	SLDestroy(&s);
}

 执行：

7️⃣尾部删除:SLPopBack

void SLPopBack(SL* psl);//尾删

一开始的思路就是把顺序表最后一个元素变为0或者-1

void SLPopBack(SL* psl)
{
    
    psl->a[psl->size - 1] = 0;这句话不好，为什么？
    psl->size--;

}

原因有两个：

1.   要是这个位置本来就是0，或者-1，那就没有意义了。

所以这时候，我们直接改成这样,干脆利落:

void SLPopBack(SL* psl)
{
    
    psl->size--;

}

这样就不会引起其它问题了吗?然后并不是。

 这是关于测试尾部删除的越界问题,以及打印值问题的测试代码

void TestSeqList3()//测试尾部删除的越界问题,以及打印值问题
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);//插入
	SLPushBack(&s, 2);//插入
	SLPushBack(&s, 3);//插入
	SLPushBack(&s, 4);//插入
	SLPushFront(&s, 5);//头插入
	SLPushFront(&s, 6);//头插入
	SLPrint(&s);//整体呈现出来应该是 6 5 1 2 3 4

	SLPopBack(&s);//尾删除
	SLPopBack(&s);//尾删除
	SLPrint(&s);//整体呈现出来应该是 6 5 1 2 

	SLPopBack(&s);//尾删除
	SLPopBack(&s);//尾删除
	SLPrint(&s);//整体呈现出来应该是 6 5 

	SLPopBack(&s);//尾删除
	SLPopBack(&s);//尾删除
	SLPopBack(&s);//尾删除-->此时顺序表已经没有元素了还要删一个
	SLPrint(&s);//这时候size有效信息个数还"欠"一个

	SLPushBack(&s, 1);//所以这个是被吃掉了~!
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPrint(&s);//整体呈现 2 3 4

	SLDestroy(&s);
}

执行:

 调试一下寻找原因:

 先大概率猜测没有问题,所以可以直接跳过打断点的过程

猜测一下，这个问题应该是删除产生的, 直接把断点打到尾删这个位置，这时候可以看到size=6，因为插入了6 5 1 2 3 4，中间扩了一次容,所以容量psl->capacity *= 2 -->为8，扩容得刚好是8

 再按F10一步一步跳过函数的内容,接着发现了size--到了-1。因为有6个数据已经删除了6次，第7次删除至少不要把size搞成-1

 那我们应该如何处理那个函数,使得它在即将删除元素越界的时候程序可以正常运行呢?

温柔的检查: 

//尾删
void SLPopBack(SL* psl)
{
	assert(psl);//应对可能传过来的NULL指针，而且好处是直接告诉你哪个文件的哪一行出问题

	//温柔检查
	if (psl->size == 0)
	{
		printf("顺序表为空,删除失败\n");
		return;//不报错任何问题,直接回答主函数。
	}
		
	psl->size--;

}

如果这个printf信息不写,那将不会返回这个信息,直接返回主函数

  暴力检查(推荐):

//尾删
void SLPopBack(SL* psl)
{
	assert(psl);

	//暴力检查
	assert(psl->size > 0);

	psl->size--;

}

关于free报错的原因:

 一般情况是内存越界了:申请的空间不够大，但是通过数组等方式遍历到并访问不是动态开辟的空间。还有就是看看指针有没有错， 以图上的（psl->a）为例子,释放的那个指针是不是指向动态内存开辟的空间,除此之外有没有指向错误。

 要是头文件处,变为typedef double SLDatatype; 

 那要写成psl->a[psl->size - 1] = 0.0;吗？

以下是可能会引发的问题:

 所以删除的意思不是把顺序表最后一个元素抹成0或1就行了。

8️⃣头部删除:SLPopFront

void SLPopFront(SL* psl, SLDatatype x);//顺序表头插

把顺序表第一个元素删除掉,接着从顺序表第二个元素开始往前移动(第2个挪动到第1个,第3个移动到第2个， 以此类推)。

void SLPopFront(SL* psl)//从后往前
{
	assert(psl);//应对可能传过来的NULL指针，而且好处是直接告诉你哪个文件的哪一行出问题

	//暴力检查
	assert(psl->size > 0);
	//温柔检查
	if (psl->size == 0)
		return;
	/*int start = 0;
	while (start < psl->size - 1)
	{
		psl->a[start] = psl->a[start + 1];
		start++;
	}*/
	/*int start = 1;
	while (start < psl->size)
	{
		psl->a[start - 1] = psl->a[start];
		start++;
	}*/
	psl->size--;

}

写法1:start从0下标开始,start<psl->size-1

  写法2:start从1下标开始,start<psl->size ​​​​

 开一组测试看看效果:

void TestSeqList4()//头部删除越界
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPrint(&s);

	SLPopFront(&s);
	SLPopFront(&s);
	SLPrint(&s);

	SLPopFront(&s);
	SLPopFront(&s);
	SLPrint(&s);

    //以下再删除就会越界
	//SLPopFront(&s);
	//SLPopFront(&s);
	//SLPrint(&s);

	SLDestroy(&s);
}

执行:最下面一行打印是因为assert。

9️⃣中间插入:SLInsert

void SLInsert(SL* psl, int pos, SLDatatype x);

//中间插入:首先要看容量，调用检查容量的函数,接着挪动
void SLInsert(SL* psl,int pos,SLDatatype x)
{
	assert(psl);//应对可能传过来的NULL指针，而且好处是直接告诉你哪个文件的哪一行出问题

	//assert(0 <= pos && 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++;
}

图解: 

假设没有assert断言pos的范围,开一组测试看看效果:记住越界是不一定报错的!

void TestSeqList5()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushBack(&s, 5);
	SLPushBack(&s, 6);
	SLPrint(&s);

	SLInsert(&s, 2, 30);
	SLPrint(&s);

	SLInsert(&s, 20, 30);//在不属于顺序表的地方,插入一个元素，越界但不一定报错！
	//SLPrint(&s);

	SLInsert(&s, -20, 30);//负数下标
	//SLPrint(&s);

}

 加了assert(0 <= pos && pos <= psl->size)之后:

这里说一下，头插和尾插都可以调用SLInsert函数，提高代码的复用性

尾插：

void SLPushBack(SL* psl, SLDatatype x)
{
	assert(psl);

	//psl->a[psl->size] = x;
	//psl->size++;

	//SLCheckCapacity(psl);

	//psl->a[psl->size++] = x;

	SLInsert(psl, psl->size, x);
}

头插：

void SLPushFront(SL* psl, SLDatatype x)
{
	assert(psl);
	//SLCheckCapacity(psl);

	 挪动数据
	//int end = psl->size - 1;
	//while (end >= 0)
	//{
	//	psl->a[end + 1] = psl->a[end];
	//	--end;
	//}

	//psl->a[0] = x;
	//psl->size++;
	SLInsert(psl, 0, x);
}

🔟中间删除:SLErase

void SLErase(SL* psl,int pos);

void SLErase(SL* psl, int pos)//从中间删除元素,也可以是首或者尾
{
	assert(psl);//应对可能传过来的NULL指针，而且好处是直接告诉你哪个文件的哪一行出问题

	assert(0 <= pos && pos < psl->size);//说明这个位置可以是顺序表的头和尾
	//assert(psl->size>0);//这句代码也可以不加，因为

	int start = pos + 1;
	while (start < psl->size)
	{
		psl->a[start - 1] = psl->a[start];
		++start;
	}

	psl->size--;
}

图解:

 再次调用这组测试,这次是为了测试从中间删除：

void TestSeqList5()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushBack(&s, 5);
	SLPushBack(&s, 6);
	SLPrint(&s);

	SLInsert(&s, 2, 30);//中间插入
	SLPrint(&s);

	//SLInsert(&s, 20, 30);
	//SLPrint(&s);

	//SLInsert(&s, -20, 30);
	//SLPrint(&s);

	SLErase(&s, 3);//删除中间下标为3的元素,把元素3删除了
	SLPrint(&s);
	 
	SLPopFront(&s);
	SLPrint(&s);

	SLPopBack(&s);
	SLPrint(&s);

	SLDestroy(&s);
}

执行:这里第三行把3干掉了

调用SLErase(函数

尾删：

void SLPopBack(SL* psl)
{
	assert(psl);
	// 暴力检查
	//assert(psl->size > 0);

	 温柔的检查
	if (psl->size == 0)
		return;

	psl->a[psl->size - 1] = 0;
	//psl->size--;

	SLErase(psl, psl->size-1);
}

头删:

void SLPopFront(SL* psl)
{
	assert(psl);
	// 暴力检查
	//assert(psl->size > 0);

	///*int start = 0;
	//while (start < psl->size-1)
	//{
	//	psl->a[start] = psl->a[start + 1];
	//	start++;
	//}*/

	//int start = 1;
	//while (start < psl->size)
	//{
	//	psl->a[start-1] = psl->a[start];
	//	start++;
	//}

	//psl->size--;

	SLErase(psl, 0);
}

1️⃣1️⃣查找:SLFind

int SLFind(SL* psl, SLDatatype x);//找到返回下标,没有找到返回-1

返回的-1也可以用其它负数,但是一般都是用-1。

int SLFind(SL* psl, SLDatatype x)//查找
{
	assert(psl);//应对可能传过来的NULL指针，而且好处是直接告诉你哪个文件的哪一行出问题

	for (int i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			return i;//返回要查找的元素的下标
		}
	}
	return -1;//走完一遍了还没找到就返回-1，因为下标不可能是负数

}

测试一组查找的代码:

void TestSeqList6()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
    SLPushBack(&s, 6);//返回这个的下标,不会返回下面那个6的下标
	SLPushBack(&s, 5);
	SLPushBack(&s, 6);
	SLPrint(&s);

	int pos = SLFind(&s, 6);
	if (pos != -1)
	{
		SLErase(&s, pos);
	}
	SLPrint(&s);

	SLDestroy(&s);
}

找到了就返回该元素的下标,然后从中间删除它,注意这里有两个6，只返回第一个6的下标,因为第一个6是先放进去的

执行: 

1️⃣2️⃣修改:SLModify

void SLModify(SL* psl, int pos, SLDatatype x);

void SLModify(SL* psl, int pos, SLDatatype x)
{
	assert(psl);//应对可能传过来的NULL指针，而且好处是直接告诉你哪个文件的哪一行出问题

	assert(0 <= pos && pos < psl->size);

	psl->a[pos] = x;
}

调用修改的代码：

void TestSeqList7()//用于测试修改
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushBack(&s, 6);
	SLPushBack(&s, 5);
	SLPushBack(&s, 6);
	SLPrint(&s);

	int pos = SLFind(&s, 6);
	if (pos != -1)
	{
		SLModify(&s, pos, 10);//4下标的6已经改成10了
	}
	SLPrint(&s);

	SLDestroy(&s);
}

 这里再测试一下assert断言的好处:应对可能传过来的NULL指针，而且好处是直接告诉你哪个文件的哪一行出问题

void TestSeqList8()
{
	SL* s = NULL;
	SLPushBack(s, 1);
	SLPushBack(s, 2);
	SLPushBack(s, 3);
	SLPrint(s);

	SLDestroy(s);
}

 三.整体实现代码

SeqLish.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>

#include<assert.h>
//静态的顺序表
//#define N 10000
//typedef int SLDatatype;
//struct SeqList
//{
//	SLDatatype a[N];
//	int size;
//};

//动态顺序表
typedef int SLDatatype;//这个位置换成double会导致问题,可能会导致全元素都是0
typedef struct SeqList
{
	SLDatatype* a;
	int size;	 //存储的有效数据的个数
	int capacity;//容量
}SL;//类型名重定义

void SLInit(SL* psl);
void SLDestroy(SL* psl);
void SLPrint(SL*psl);// 顺序表打印


void SLPushBack(SL* psl, SLDatatype x);//尾插
void SLPushFront(SL* psl, SLDatatype x);//头插
void SLPopBack(SL* psl);//尾删
void SLPopFront(SL* psl);//头删

void SLInsert(SL* psl, int pos, SLDatatype x);
void SLErase(SL* psl,int pos);

//找到返回下标,没有找到返回-1
int SLFind(SL* psl, SLDatatype x);

void SLModify(SL* psl, int pos, SLDatatype x);

SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"

//顺序表的要求就是连续存储




void SLInit(SL* psl)
{
	psl->a = (SLDatatype*)malloc(sizeof(SLDatatype) * 4);//malloc扩容,因为malloc类型是->void* malloc (size_t size);所以需要强制转换
	//打印错误信息?
	if (psl->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	psl->capacity = 4;//使用结构体指针指向访问对象的成员,当前容量
	psl->size = 0;//当前有效信息个数
}


void SLDestroy(SL* psl)//销毁不是整没了，而是还给操作系统了
{
	free(psl->a);
	psl->a = NULL;
	psl->size = 0;
	psl->capacity = 0;
}
void SLPrint(SL* psl)
{
	for (int i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

//?
void SLCheckCapacity(SL* psl)
{
	if (psl->size == psl->capacity)//有效信息的个数等于当前容量
	{
		SLDatatype* tmp =(SLDatatype*)realloc(psl->a, sizeof(SLDatatype) * psl->capacity * 2);
		if (tmp == NULL)//申请空间过大可能会申请失败
		{
			perror("realloc fail");
			return;
		}
		psl->a = tmp;//原地扩容用的是原来的地址，异地扩容用的是新的
		psl->capacity *= 2;//当前容量*2
	}
}
//尾插法
void SLPushBack(SL* psl, SLDatatype x)
{
	assert(psl);	
	SLCheckCapacity(psl);
	psl->a[psl->size++] = x;//检查当前容量,不够则扩容


}
//头插法必须从后往前挪动数据，不能从往前往后挪动
void SLPushFront(SL* psl, SLDatatype x)
{
	assert(psl);
	SLCheckCapacity(psl);

	//挪动数据
	int end = psl->size-1;
	while (end >= 0)
	{
		psl->a[end + 1] = psl->a[end];
		--end;
	}
	psl->a[0] = x;
	psl->size++;
}



//尾删
void SLPopBack(SL* psl)
{
	assert(psl);

	//暴力检查
	//assert(psl->size > 0);
	//温柔检查
	if (psl->size == 0)
	{
		printf("顺序表为空,删除失败\n");
		return;//不报错任何问题,直接回答主函数。
	}
		

    //psl->a[psl->size - 1] = 0;这句话不好,就是说把最后一个位置变成0
	psl->size--;

}


void SLPopFront(SL* psl)//从后往前
{
	assert(psl);

	//暴力检查
	assert(psl->size > 0);
	//温柔检查
	if (psl->size == 0)
		return;
	int start = 0;
	while (start < psl->size - 1)
	{
		psl->a[start] = psl->a[start + 1];
		start++;
	}
	/*int start = 1;
	while (start < psl->size)
	{
		psl->a[start - 1] = psl->a[start];
		start++;
	}*/
	psl->size--;

}

//中间插入:首先要看容量，调用检查容量的函数,接着挪动
void SLInsert(SL* psl,int pos,SLDatatype x)
{
	assert(psl);

	assert(0 <= pos && 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++;
}

void SLErase(SL* psl, int pos)//从中间删除元素,也可以是首或者尾
{
	assert(psl);
	assert(0 <= pos && pos < psl->size);
	//assert(psl->size>0);

	int start = pos + 1;
	while (start < psl->size)
	{
		psl->a[start - 1] = psl->a[start];
		++start;
	}

	psl->size--;
}

int SLFind(SL* psl, SLDatatype x)//查找
{
	assert(psl);

	for (int i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			return i;
		}
	}
	return -1;//走完一遍了还没找到就返回-1，因为下标不可能是负数。

}


void SLModify(SL* psl, int pos, SLDatatype x)
{
	assert(psl);

	assert(0 <= pos && pos < psl->size);

	psl->a[pos] = x;
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"
void TestSeqList1()
{
	SL s;
	SLInit(&s);
	
	SLPushBack(&s, 1);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushFront(&s,5);
	
	SLPrint(&s);

	SLDestroy(&s);
}

void TestSeqList2()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushFront(&s, 5);
	SLPushFront(&s, 6);
	SLPrint(&s);

	SLDestroy(&s);
}

void TestSeqList3()//测试尾部删除的越界问题,以及打印值问题
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushFront(&s, 5);
	SLPushFront(&s, 6);
	SLPrint(&s);

	SLPopBack(&s);
	SLPopBack(&s);
	SLPrint(&s);

	SLPopBack(&s);
	SLPopBack(&s);
	SLPrint(&s);

	SLPopBack(&s);
	SLPopBack(&s);
	SLPopBack(&s);
	SLPrint(&s);

	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPrint(&s);

	SLDestroy(&s);
}

void TestSeqList4()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPrint(&s);

	SLPopFront(&s);
	SLPopFront(&s);
	SLPrint(&s);

	SLPopFront(&s);
	SLPopFront(&s);
	SLPrint(&s);

	//SLPopFront(&s);
	//SLPopFront(&s);
	//SLPrint(&s);

	SLDestroy(&s);
}

void TestSeqList5()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushBack(&s, 5);
	SLPushBack(&s, 6);
	SLPrint(&s);

	SLInsert(&s, 2, 30);
	SLPrint(&s);

	//SLInsert(&s, 20, 30);
	//SLPrint(&s);

	//SLInsert(&s, -20, 30);
	//SLPrint(&s);

	SLErase(&s, 3);
	SLPrint(&s);
	 
	SLPopFront(&s);
	SLPrint(&s);

	SLPopBack(&s);
	SLPrint(&s);

	SLDestroy(&s);
}

void TestSeqList6()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushBack(&s, 6);
	SLPushBack(&s, 5);
	SLPushBack(&s, 6);
	SLPrint(&s);

	int pos = SLFind(&s, 6);
	if (pos != -1)
	{
		SLErase(&s, pos);
	}
	SLPrint(&s);

	SLDestroy(&s);
}


void TestSeqList7()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushBack(&s, 6);
	SLPushBack(&s, 5);
	SLPushBack(&s, 6);
	SLPrint(&s);

	int pos = SLFind(&s, 6);
	if (pos != -1)
	{
		SLModify(&s, pos, 10);
	}
	SLPrint(&s);

	SLDestroy(&s);
}

void TestSeqList8()
{
	SL* s = NULL;
	SLPushBack(s, 1);
	SLPushBack(s, 2);
	SLPushBack(s, 3);
	SLPrint(s);

	SLDestroy(s);
}

void menu()
{
	printf("***************************************\n");
	printf("1、尾插数据  2、尾删数据\n");
	printf("3、头插数据  4、头删数据\n");
	printf("5、打印数据  -1、退出\n");
	printf("***************************************\n");
}

int main()
{
	//TestSeqList1();
	TestSeqList2();
	
	//TestSeqList3();
	//TestSeqList5();
	//TestSeqList8();


	return 0;
}

欢迎大佬指正，非常感谢您的支持!

Dream_Chaser～
关注
  • 29
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 42
    评论
专栏目录
数据结构C语言-顺序表PPT课件.ppt
12-27
数据结构C语言-顺序表PPT课件.ppt
c代码-3.给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例： 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807 /** * Definition for singly-linked li
07-14
c代码-3.给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例： 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807 /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){ }
顺序表C++_数据结构实验--顺序表；C++语言_
09-30
采用C++语言实现数据结构中顺序表的基本运算与操作
【数字设计与计算机体系结构】2021-09-26-数字设计与计算机体系结构课程（四）
m0_51746993的博客
09-27 1351
一、计算机中的数制 进位计数制 数制 数码 权 基数 书写后缀 十进制 （0~9） 10k 10 D / d / ()10 二进制 （0~1） 2k 2 B / b / ()2 八进制 （0~7） 8k 8 O / o / ()8 十六进制 （0~15） 16k 16 H / h / ()16 进位计数制表示方法： 以二进制为例：（N）2=Dn-1×2n-1+Dn-2×2n-2+Dn-3×2n-3+……+Dm×2-m; 其中，n为整数位，m为小数位； 进位计数制口诀: 以
【数据结构】插入排序详细图解（一看就懂）
陈大大陈的博客
05-31 2204
我们将原数组空间看成两个部分，前边是有序部分，后边是无序部分，有序部分我们默认为它就已经是排好序的，在尾部新加入的元素有可能会导致整个有序数组变得无序，因此我们需要进行调整。 调整方式就是将新加入的元素进行对比并往前移动，新加入元素和它前边的元素进行对比，如果它比它前边的元素小，则二者互换位置，不断重复这个过程，直到它前边的元素小于它才会停止，这样一来，他就仍然是有序数组。
数据结构-顺序表-C语言实现顺序表相关功能-数据结构学习
最新发布
05-22
C语言实现的数据结构中的顺序表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习 对顺序表边界操作的判定 实现了以下功能： 创建顺序表 向顺序表中插入元素(尾插法，...
数据结构-C语言描述（顺序表、链表）
04-01
水一下学校的实验报告，注释没有认真写，勿喷。
数据结构学习--线性表及其应用--顺序表
06-25
在众多数据结构当中，线性表是最简单、也是最基本的一个。线性表按存储结构分，可 分为顺序表和链表，它们各有特色。本程序主要目的在于帮助同学熟练掌握线性表的基本 操作在顺序存储结构上的实现，顺序表的优点是...
横竖三个数的和相等_二年级思维数学：数的拆分，拆分技巧必须掌握，含视频教学...
weixin_33585889的博客
01-02 5447
【思维策略】按要求把一些数分解成几个数相加的形式，这不仅可以提高运算能力，更能促进你积极地去思考问题，分析问题，使你的头脑更聪明。怎样才能找到全部答案，不出现差错呢？分析数的时候，一定要弄懂题中要求，使分析的过程按一定的顺序进行，如果要拆成规定的个数，可以按从大到小的顺序拆；如果没有规定个数，可以按从少到多的顺序拆。只有这样，才能的找到符合题意的所有分拆方式。重点难点：拆数三步骤：1、拆谁？2、拆...
枚举（enum)/共用体（union)/结构体（struct)---详解
2302_80345385的博客
04-24 1183
数据结构的储备知识，必须拿下！！
【Java数据结构】常见排序详解
weixin_46913665的博客
02-28 1335
文章目录 一、排序的概念和分类 1.排序的基本概念 2.排序的稳定性 二、常见排序 1.直接插入排序 2.希尔排序 3.简单选择排序 4.堆排序 5.冒泡排序 6.快速排序 6.1.递归快速排序 6.1.1.快排优化 6.2.非递归方式实现 7.归并排序
数据结构：链表
2301_79526467的博客
12-02 918
链表与顺序表的区别 1.单链表的增（头尾插），删除结点，查改，销毁链表 2.双链表的增（头尾插），删除结点，查改，链表销毁 3.循环链表 思路以及每一步骤图片详解
[完整]首届盘古石杯电子数据取证大赛晋级赛Writeup
热门推荐
啥都弄
05-11 1万+
通过Potato得到com.pim.imm，搜索得到数据库文件夹坚果pro3/data/data/com.qim.imm/databases/im_db_225_18969939616_8AF2C81F-58C2-8459-C492-9C4F65E6BC1E.db之后分析表得知，该表为聊天记录，使用gpt写脚本，进行base64解码原理如下：打开文件，对文件中的第三列除去第一行的其他内容进行base64解码，并生成新文件a.xls。
数据结构-栈
2202_75509654的博客
05-19 395
顺序栈：int maxlen;int top;}sqstack;
数据结构 —— 栈 与 队列
2301_78957570的博客
05-22 368
栈（Stack）是一种特殊的线性数据结构，它遵循后进先出（LIFO，Last In First Out）的原则。栈只允许在一端插入和删除数据，这一端被称为栈顶（top），另一端被称为栈底（bottom）。就像弹匣一样，先压进去的子弹会最后被发射，最后压进去的子弹反而最先被发射。
数据结构_栈和队列学习
weixin_46571256的博客
05-19 445
简单易实现，空间固定，可能造成空间浪费或溢出。：检查栈顶指针是否为NULL。
数据结构（一）顺序表
weixin_44254079的博客
05-22 1173
数据结构 C语言
【高阶数据结构】AVL树的旋转与底层(C++实现)
c565114的博客
05-19 336
双旋的情况就是在60这个子树上插入一个新的结点，插入过后需要经过两次旋转。旋转后的结果就是30和90都变成了60的子树。原本为60的子树，变成了30和90的子树。右单旋的所有情况可以抽象为上图：图中，a,b,c均为高度为h（h取0，1，2......）的AVL子树。对比一下右单旋的图片，左右双旋的抽象图是把30结点的右子树细致的分为60的结点和60的左右子树。从程序运行结果可知：在Release版本下，插入100万个随机数，其中实际插入约63万个数值。1.按照搜索树的规则插入，然后更新父亲的平衡因子。
哈希表---闭散列
德发哆啦的博客
05-19 434
当我们用哈希函数的时候，其中一个就是取这个表的长度len,按照哈希函数：Hash(key) = key% len,将这个位置映射到表中通过上面的除留余数法，会有的问题，可以通过来解决也叫，通过线性探测，依次找后面的位置存储。
数据结构c语言-顺序栈
10-05
在C语言中，顺序栈的存储结构可以使用一个一维数组来存放栈中的元素，同时使用一个指示器top来指示栈顶的位置。在进行进栈和出栈操作时，需要更新top的值，使其指向栈顶元素。 下面是一种常见的顺序栈的定义和基本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 42
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Dream_Chaser～

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

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

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

打赏作者

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

抵扣说明：

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

余额充值