【数据结构】顺序表

原创 于 2024-11-02 13:29:06 发布 · 375 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c语言

一.初识顺序表

1.顺序表的底层结构是数组。

2.顺序表是线性表（具有相同特性的数据结构的集合）的一种，物理结构并不一定连续，逻辑结构一定连续。

二.顺序表的分类

1.静态顺序表

概念：使用定长数组存储元素。

 struct Seqlist
{
int a[N];//定长数组
int size;//有效数据个数
}；

缺陷：空间给少了不够用，给多了造成空间浪费。

2.动态顺序表

struct Seqlist
{
int *a;       //可增容
int size;     //有效数据个数
int capacity;//空间容量
};

优点：可以根据需求增容。

三.动态顺序表的实现

建立动态顺序表结构体

typedef int SLDataType;
// 动态顺序表 -- 按需申请
typedef struct SeqList
{
SLDataType* a;
int size;
// 有效数据个数
int capacity; // 空间容量
}SL;;

顺序表的初始化

动态顺序表中有两个变量，一个指针。初始化就要把变量等于零、指针置为空；但是要先判断传过来的实参地址是否为空。

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

顺序表的销毁

顺序表的底层结构是数组，而在动态顺序表中只有指针a的空间是向系统申请的，所以顺序表的销毁就是要free掉结构体中的数组并且置为空、其他变量置为零。

void SLDestroy(SL* ps)
{
assert(ps);
if(ps->a)      //==ps->a!=NULL
{
free(ps->a);
}
ps->a=NULL;
ps->size=ps->capacity=0;
}

顺序表的打印

按照数组的打印方式——遍历每一个数组。

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

顺序表的增容

void SLCheckCapacity(SL* ps)
{
if(ps->size==ps->capacity)
{
int newcapacity=ps->capacity==0?4:2*ps->capacity;//三目表达式
//空间不够--2倍增韧
SLDataType *tmp=(SLDataType*)realloc(ps->a,sizeof(SLDataType)*newcapacity);
//ps->capacity初始化的时候为0，但0乘任何数都为0，所以定义变量newcapacity。
if(tmp==NULL)
{
perror("realloc fail!");
exit(1);
}
ps->a=tmp;
ps->capacity=newcapacity;
}
}

顺序表的尾插

void SLPushBack(SL* ps, SLDataType x)
{
assert(ps);
//插入之前先检查空间是否足够
SLCheckCapacity(ps);
ps->a[ps->size++]=x;//不要忘记给ps->size加1
}

顺序表的头插

头插就是把要插入的数据放在ps->a[0]的位置，故可以把原本的数据都往后挪一位。

void SLPushFront(SL* ps, SLDataType x)
{
assert(ps);
SLCheckCapacity(ps);
for(int i=ps->size;i>0;i--)
{
ps->a[i]=ps->a[i-1];
}
ps->a[0]=x;
ps->size++;
}

顺序表的尾删

删除最后一个数据。

void SLPopBack(SL* ps)
{
assert(ps&&ps->size);
//如果顺序表里面个数为0还减减，就会造成越界的问题
--ps->size;
}

顺序表的头删

即删除ps->a[0]的数据。思路：把后面的数往前挪覆盖前面的ps->a[0]，并让ps->size--。

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

在指定位置之前插入数据

void SLInsert(SL* ps, int pos, SLDataType x)
{
assert(ps);
assert(pos>=0&&pos<ps->size);
//插入数据之前都要判断空间是否足够
SLCheckCapacity(ps);
//让pos往后的数据往后挪
for(int i=ps->size;i>pos;i--)
{
ps->a[i]=ps->a[i-1];
}
ps->a[pos]=x;
ps->size++;
}

删除指定位置的数据

思路：让pos之后的数据往前挪，覆盖ps->a[pos]的数据。

void SLErase(SL* ps, int pos)
{
assert(ps);
assert(pos>=0&&pos<ps->size);//确保pos没有越界
for(int i=pos;i<ps->size-1;i++)
{
ps->a[i]=ps->a[i+1];
}
ps->size--;
}

查找数据

思路：遍历每一个数据并判断是否为要查找的数据，并返回下标。

int SLFind(SL* ps, SLDataType x)
{
for(int i=0;i<ps->size;i++)
{
if(ps->a[i]==x)
{
return i;
}
}
//已遍历完数据，故没找着，返回无效下标
return -1;
}

四.代码完整展示

Seqlist.h

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDataType;
// 动态顺序表 -- 按需申请
typedef struct SeqList
{
	SLDataType* a;
	int size;
	// 有效数据个数
	int capacity; // 空间容量
}SL;
//顺序表的初始化
void SLInit(SL* ps);
//顺序表的销毁
void SLDestroy(SL* ps);
//顺序表的打印
void SLPrint(SL* ps);
//顺序表空间容量的检查
void SLCheckCapacity(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);
//查找数据
int SLFind(SL* ps, SLDataType x);

seqlist.c

#include"seqlist.h"
void SLInit(SL* ps)
{
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}
void SLDestroy(SL* ps)
{
	assert(ps);
	if(ps->a)      //==ps->a!=NULL
	{
	free(ps->a);
	}
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}
void SLPrint(SL* ps)
{
	assert(ps);
		for (int i = 0; i < ps->size; i++)
		{
			printf("%d ", ps->a[i]);
		}
	printf("\n");
}
void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;//三目表达式
		//空间不够--2倍增韧
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * newcapacity);
		//ps->capacity初始化的时候为0，但0乘任何数都为0，所以定义变量newcapacity。
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	//插入之前先检查空间是否足够
	SLCheckCapacity(ps);
	ps->a[ps->size++] = x;//不要忘记给ps->size加1
}
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	for (int i = ps->size; i > 0; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[0] = x;
	ps->size++;
}
void SLPopBack(SL* ps)
{
	assert(ps && ps->size);
	//如果顺序表里面个数为0还减减，就会造成越界的问题
	--ps->size;
}
void SLPopFront(SL* ps)
{
	assert(ps->size && ps);
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	//插入数据之前都要判断空间是否足够
	SLCheckCapacity(ps);
	//让pos往后的数据往后挪
	for (int i = ps->size; i > pos; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[pos] = x;
	ps->size++;
}
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);//确保pos没有越界
	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}
int SLFind(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	//已遍历完数据，故没找着，返回无效下标
	return -1;
}

test.c

#include"seqlist.h"
void test()
{
	SL ps;
	SLInit(&ps);
	SLPushBack(&ps, 1);
	SLPushBack(&ps, 2);
	SLPushBack(&ps, 3);
	SLPushBack(&ps, 4);
	SLPushFront(&ps, 7);
	SLPopBack(&ps);
	SLPopFront(&ps);
	SLInsert(&ps, 2, 5);
	SLErase(&ps, 2);
	
	SLPrint(&ps);
	if (SLFind(&ps, 2)>=0)
	{
		printf("找到了，下标为：%d", SLFind(&ps, 2));
	}
	else
		printf("没找到");
	SLDestroy(&ps);
	
}
int main()
{
	test();
	return 0;
}

运行结果

SLDestory函数的运行结果需要调试

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值