顺序表专题（1）

不吃芹菜的喵星人

已于 2024-05-17 20:26:56 修改

阅读量845

点赞数 31

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

于 2024-05-17 20:19:31 首次发布

本文链接：https://blog.csdn.net/2301_77924144/article/details/138999751

版权

1.顺序表的概念

顺序表是线性表的一种。

线性表就是具有相同特性的数据结构的集合，物理结构不一定连续，但是逻辑结构一定是连续的。

顺序表的底层是数组，所以它的物理结构和逻辑结构都是连续的。

2.顺序表的分类

2.1静态顺序表

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

缺点：数组大小给小了不够用，给大了，空间浪费。

2.2动态顺序表

struct SeqList
{
	int* arr;//动态内存开辟，确定大小之后再去动态申请内存
	int size;//有效数据个数
	int capacity;//空间大小
};

优点：动态增容，按需申请空间

3.动态顺序表的实现

3.1准备

首先我们需要建立三个文件：
在这里插入图片描述
SuqList.h文件用来写顺序表功能函数的声明

#pragma once
#include<stdio.h>//打印要用
#include<stdlib.h>//扩容要用
#include<assert.h>//断言要用

typedef int SLDatatype;//类型统一定义为SLDatatype
//这样方便后续如果要修改int这个类型可以直接在这一行代码修改就可以了。
struct SuqList
{
	SLDatatype* arr;//动态申请内存空间
	int size;//记录当前数据的有效个数
	int capacity;//记录空间大小
};

typedef struct SuqList SL;//给这个顺序表起个名字叫SL

//顺序表的初始化函数声明,参数是SL这个顺序表的地址ps
void SLInit(SL* ps);

//插入数据之前要判断空间大小够不够，如果不够要扩容
//扩容声明
void SLCheckCapacity(SL* ps);

//顺序表的头插声明
void SLPushFront(SL* ps, SLDatatype x);

//顺序表的尾插声明
void SLPushBack(SL* ps, SLDatatype x);

//顺序表的头删声明
void SLPopFront(SL* ps);

//顺序表的尾删声明
void SLPopBack(SL* ps);

//在顺序表指定位置之前插入数据的声明
void SLInsert(SL* ps, int pos, SLDatatype x);

//在顺序表指定位置之前删除数据的声明
void SLDelete(SL* ps, int pos, SLDatatype x);

//查找顺序表中的指定数据函数的声明
int SLFind(SL* ps, SLDatatype x);

//打印顺序表中数据函数的声明
void SLPrint(SL s);

//顺序表的销毁 函数声明
void SLDestroy(SL* ps);

SuqList.c文件用来写顺序表功能函数的实现。

test.c文件用来测试我们写得函数功能能否达到我们预期的效果。

都要用到头文件中声明过的函数，就要包含头文件，方式如下：

#include"SuqList.h"

3.2顺序表的初始化

//顺序表的初始化实现
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

初始状态下，数组为空，有效数据和空间大小都为空。

3.3顺序表的扩容

思路：

当有效数据size=空间大小capacity时，表示空间已经满了；
扩容一般是扩大2倍或3倍，也就是原来空间的2倍或3倍，所以空间capacity一定不能为0。

//在插入数据之前要判断空间够不够，如果不够要进行扩容
void SLCheckCapacity(SL* ps)
{
	if (ps->capacity == ps->size)
	{
		//满了，空间不够，需要扩容，申请空间
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;//先判断空间是否为0，不为0这个新空间就为原来的两倍
		SLDatatype* tmp = (SLDatatype*)realloc(ps->arr, newCapacity * sizeof(SLDatatype));//用realloc向内存申请2*ps->capacity*sizeof(SLDatatype)大小的空间

		if (tmp == NULL)//如果申请空间失败
		{
			perror("realloc");//申请失败给个提示是在realloc这里出错了
			exit(1);//申请失败直接退出程序
		}

		//如果申请成功
		ps->arr = tmp;//申请空间以后把这个空间tmp给给arr
		ps->capacity = newCapacity;//现在是新的空间了
	}
}

3.4顺序表的头插

思路：

把所有原有的数据整体向后挪动一位，这需要一个for循环；
循环的第一个步骤是arr[size] = arr[size-1]，所以从int i = ps->size开始；
循环的最后一个步骤是arr[1]=arr[0]，所以i>0是循环的判断条件；
从后往前循环的，所以每次循环都会使i-1，所以有i--；
最后再把要插入的数据x插到arr[0]；
有效数据增加size++。

//顺序表的头插实现
void SLPushFront(SL* ps,SLDatatype x)
{
	assert(ps);//指针不能为空
	SLCheckCapacity(ps);//插入数据之前检查空间够不够，如果不够这个函数会申请空间

	//先把所有的数据向后挪动一位
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//最后一个是arr[1]=arr[0],所以i最小等于1
	}

	ps->arr[0] = x;//把x插在头部
	ps->size++;//有效数据增加
}

3.5顺序表的尾插

//顺序表的尾插实现
void SLPushBack(SL* ps, SLDatatype x)
{
	assert(ps);//传入的指针不能为空
	SLCheckCapacity(ps);//插入数据之前检查空间够不够，如果不够这个函数会申请空间
	ps->arr[ps->size] = x;
	ps->size++;
	//也可以写成ps->arr[ps->size++]=x;
}

3.6顺序表的头删

思路：

把数据整体向前挪动一位，就把顺序表第一个位置的数据删除了；
需要写一个循环，循环的开始是arr[0] = arr[1]，所以i=0;
循环的最后一个步骤是arr[size-1] = arr[size]，所以i<size-1。

//顺序表的头删实现
void SLPopFront(SL* ps)
{
	assert(ps);//传入的指针不能为空
	assert(ps->size);//有效数据不能为空

	//数据整体向前挪动一位，最后一个步骤是把size-1挪到size-2,所以i最大是size-2
	for (int i = 0; i < ps->size-1 ; i++)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->size--;//有效数据减减
}

3.7顺序表的尾删

//顺序表的尾删
void SLPopBack(SL* ps)
{
	assert(ps);//传入的指针不能为空
	assert(ps->size);//有效数据不能为空
	
	ps->size--;//尾删只需有效数据减减就好了
}

3.8在顺序表指定位置之前插入数据

思路：

让指定的位置pos及之后的位置整体向后挪动一位，则需要一个循环；
循环的第一步是arr[size] = arr[size-1]，所以i=size；
循环的最后一步是arr[pos+1] = arr[pos]，所以i>pos。

//在顺序表指定位置之前插入数据的实现
void SLInsert(SL* ps, int pos, SLDatatype x)
{
	assert(ps);//传入的指针不能为空
	assert(pos >= 0 && pos <= ps->size);//指向的位置要有效，下标都是>=0的，不能越界访问所以要比有效数字size小。
	//插入数据之前，要判断空间够不够，不够要申请空间
	SLCheckCapacity(ps);
	//让指定的位置pos及之后的位置整体向后挪动一位
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];//最后一个动作是arr[pos+1]=arr[pos],所以结束条件是i>pos
	}
	ps->arr[pos] = x;//在pos这个位置插入x
	ps->size++;//有效数据增加
}

3.9删除指定位置的数据

思路如图：
在这里插入图片描述

//删除指定位置的数据
void SLDelete(SL* ps, int pos, SLDatatype x)
{
	assert(ps);//传入的指针不能为空
	assert(pos >= 0 && pos < ps->size);//指向的位置要有效，下标都是>=0的，不能越界访问所以要比有效数字size小。

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

3.10查找顺序表中的指定数据

//查找顺序表中的指定数据
int SLFind(SL* ps, SLDatatype x)
{
	assert(ps);//传入的指针不能为空
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			//找到了
			return i;//返回下标
		}
	}
	//没有找到
	return -1;//返回一个无效的下标
}

3.11打印顺序表

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

}

3.12顺序表的销毁

//顺序表的销毁 函数实现
void SLDestroy(SL* ps)
{
	if (ps->arr)
	{
		free(ps->arr);//销毁，释放
	}
	ps->arr = NULL; //避免ps->arr成为野指针
	ps->size = ps->capacity = 0;
}

3.13测试

3.13.1测试头插

void SLtest01()
{
	//测试头插
	SLPushFront(&sl, 1);//1
	SLPushFront(&sl, 2);//2 1
	SLPushFront(&sl, 3);//3 2 1
	SLPushFront(&sl, 4);//4 3 2 1
	SLPushFront(&sl, 5);//5 4 3 2 1
	SLPrint(sl);
	//预期结果是5 4 3 2 1
	SLDestroy(&sl);
}

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

结果：
在这里插入图片描述

3.13.2测试尾插

void SLtest01()
{
	//测试尾插
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);//尾插1 2 3 4 5
	SLPrint(sl);
	//预期结果是1 2 3 4 5
	SLDestroy(&sl);
}

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

结果：
在这里插入图片描述

3.13.3测试头删

void SLtest01()
{
	//测试头插
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 5);//头插1 2 3 4 5
	SLPrint(sl);
	//预期结果是5 4 3 2 1

	//测试头删
	SLPopFront(&sl);
	SLPrint(sl);
	//预期结果4 3 2 1
	SLDestroy(&sl);
}

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

结果：
在这里插入图片描述

3.13.4测试尾删

void SLtest01()
{
	//测试头插
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 5);//头插1 2 3 4 5
	SLPrint(sl);
	//预期结果是5 4 3 2 1

	//测试尾删
	SLPopBack(&sl);
	SLPrint(sl);
	//预期结果5 4 3 2
	SLDestroy(&sl);
}

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

结果：
在这里插入图片描述

3.13.5测试在指定位置位置之前插入数据

void SLtest01()
{
	//测试头插
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 5);//头插1 2 3 4 5
	SLPrint(sl);
	//预期结果是5 4 3 2 1

	//测试在指定位置位置之前插入数据
	SLInsert(&sl, 0, 88);//在开头插入88           //88 5 4 3 2 1
	SLInsert(&sl, 3, 99);//在下标为3的前面插入99   //88 5 4 99 3 2 1
	SLInsert(&sl, 5, 100);//在下标为5的前面插入100 //88 5 4 99 3 100 2 1
	SLPrint(sl);
	//预期结果88 5 4 99 3 100 2 1
	SLDestroy(&sl);
}

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

结果：
在这里插入图片描述

3.13.6测试删除指定位置的数据

void SLtest01()
{
	//测试头插
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 5);//头插1 2 3 4 5
	SLPrint(sl);
	//预期结果是5 4 3 2 1

	SLDelete(&sl,0);//删除下标为0的数据//4 3 2 1 
	SLDelete(&sl,3);//删除下标为3的数据//4 3 2
	SLDelete(&sl,4);//删除下标为4的数据//已经没有下标4的数据了
	SLPrint(sl);
	//预期结果报错
	
	SLDestroy(&sl);
}

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

结果：
在这里插入图片描述

3.13.7测试查找数据

void SLtest01()
{
	//测试头插
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 5);//头插1 2 3 4 5
	SLPrint(sl);
	//预期结果是5 4 3 2 1

	//测试查找数据
	int find01=SLFind(&sl, 5);//查找5，预期找到了
	if (find01 < 0)
	{
		//没找到
		printf("没找到\n");
	}
	else
		printf("找到了\n");

	int find02 =SLFind(&sl, 9);//查找9，预期找不到
	if (find02 < 0)
	{
		printf("没找到\n");
	}
	else
		printf("找到了\n");
		
	SLDestroy(&sl);
}

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

结果：
在这里插入图片描述
注意：我们在写完一个函数以后最好就要测试一个函数，不然万一出现的错误太多，会很麻烦！

顺序表专题第二节马上肝出来（马不停蹄中…）

如果觉得有所收获，还请点赞，点个关注，我真的会开心好久好久哒！！！
在这里插入图片描述

不吃芹菜的喵星人

关注

31
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
顺序表专题（1）

我们在写完一个函数以后最好就要测试一个函数，不然万一出现的错误太多，会很麻烦！顺序表的底层是数组，所以它的物理结构和逻辑结构都是连续的。的集合，物理结构不一定连续，但是逻辑结构一定是连续的。文件用来测试我们写得函数功能能否达到我们预期的效果。初始状态下，数组为空，有效数据和空间大小都为空。缺点：数组大小给小了不够用，给大了，空间浪费。文件用来写顺序表功能函数的实现。文件用来写顺序表功能函数的声明。优点：动态增容，按需申请空间。线性表就是具有相同特性的。顺序表是线性表的一种。
复制链接

扫一扫