顺序表的概念和增删查改接口实现

三更雨里一盏灯

已于 2023-02-14 21:38:51 修改

阅读量155

点赞数 1

文章标签：数据结构数据库

于 2023-02-14 21:06:35 首次发布

本文链接：https://blog.csdn.net/qq_26133677/article/details/129032750

版权

顺序表的概念

数据结构，主要就是对数据完成增删查改

1.线性表：顺序表、链表、栈、队列、字符串...
顺序表：本质上数组，但是在数组的基础上，要求数据是从头开始连续存储，不能有跳跃

增删查改接口实现

首先创建一个SList.h，将我们所需要的接口函数和定义的类型放入其中

typedef struct SeqList
{
	SLDataType* a;
	int size;//表示数组中存储了多少个数据
	int capacity;//表示数组实际能存储数据的空间容量的大小
}SL;
// 接口函数
void SeqListInit(SL* ps);
void Print_SeqList(SL* ps);
void SeqListPushBack(SL* ps, SLDataType x);
void SeqListPopBack(SL* ps	);
void SeqListPushFront(SL* ps, SLDataType x);
void SeqListPopFront(SL* ps);
void SeqListDestory(SL* ps);
int SeqListFind(SL* ps,SLDataType x);				//找到返回x坐标，没有找到返回-1
void SeqListInsert(SL* ps, int pos, SLDataType x);	//在pos下标处插入
void SeqListErase(SL* ps, int pos);					//删除pos位置的数据

链表初始化和释放的函数接口

申请了空间后，需要记得free掉。

// 释放空间
void SeqListDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}
//顺序表的初始化
void SeqListInit(SL* ps)
{
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

尾插一个数据+扩容

每次尾插一个数据的时候，就进行一次检测空间是否足够，当空间不够的时候，进行扩容

void SeqListPushBack(SL* ps, SLDataType x)	
{
	//扩容检测
	SeqListCheckCapaticy(ps);
	ps->a[ps->size] = x;
	ps->size++;
}
//扩容
void SeqListCheckCapaticy(SL* ps)
 {
	if (ps->size == ps->capacity)
	{
		//若没有空间或空间不足，则先扩容
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("SeqList::realloc");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
 }

尾删一个数据

ps->a[ps->size - 1] = 0;// 真正确认有效数据的是size，当size--后，最后一位有效数据自动删去。

void SeqListPopBack(SL* ps)
{
	if (ps->size > 0)
	{
		ps->size--;
	}
}

void SeqListPushBack(SL* ps, SLDataType x) //尾插一个数据
此时空间有以下几种情况：
1.整个顺序表没有空间
2.空间不够扩容
3.空间足够，直接插入数据

头插一个数据

需要把尾部的数据一个个往后移动

void SeqListPushFront(SL* ps, SLDataType x)
{
	SeqListCheckCapaticy(ps);
	//挪动数据
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

头删一个数据

void SeqListPopFront(SL* ps)
{
	if (ps->size > 0)
	{
		//挪动数据
		int begin = 1;
		while (begin < ps->size)
		{
			ps->a[begin - 1] = ps->a[begin];
			begin++;
		}
		ps->size--;
	}
}

查找一个数据

int SeqListFind(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (x == ps->a[i])
		{
			return i;
		}
	}
	return -1;
}

在pos下标处插入一个数据

void SeqListInsert(SL* ps, int pos, SLDataType x)
{
	SeqListCheckCapaticy(ps);
	assert(pos >= 0 && pos < ps->size);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

当实现了这个函数后，前面的头插和尾插就便可以复用该函数实现。

删除在pos下标处的数据

void SeqListErase(SL* ps, int pos)
{
	assert(pos >= 0 && pos <= ps->size);
	int begin = pos;
	while (begin < ps->size)
	{
		ps->a[begin] = ps->a[begin+1];
		begin++;
	}
	ps->size--;
}

到此，顺序表增删查改的基本功能实现了。

顺序表优点：

支持随机访问

缓冲空间命中率高

顺序表缺陷：

1.空间不够了需要扩容，扩容是付出代价
扩容两总模式:原地扩容（地址后面存在足够的连续空间），异地扩容（地址后面没有足够的连续空间_代价高）
2.避免频繁扩容，我们满了基本都是扩容2倍，可能会造成一些空间浪费
3.顺序表要求数据是从开始位置连续存储，那么我们在头部或者中间插入数据，就需要挪动数据，效率不高
针对顺序表的缺陷：
设计了链表