C语言---顺序表（详解）---数据结构

本文链接：https://blog.csdn.net/weixin_57535054/article/details/122776589

我们直接切入主题

1.首先这次写的顺序表的动态的，因为静态的弊端较多。

2.顺序表的功能函数有：初始化丶申请动态内存顺序表的头部，尾部的插入和删除丶在特定位置的插入和删除丶打印顺序表丶释放动态内存

需要用到的头文件

我们先给类型重命名

原因是：以后还需要用到顺序表时，插入的不一定是你当前使用的类型，如果要改还需要一个个改，非常麻烦，为了以后方便，我们需要改类型时，直接给类型重命名这里改，就可以了，更加节省时间。

创建一个结构体里面包含

1指向动态开辟数组的指针。*a

2记录有效数据的个数 size

3容量的大小 capacity

前置准备写好了，可以开始实现各个函数功能了。

1 初始化

初始化较为简单指针置为空，size置为0，需要注意的是容量大小要置为4（或者其他大小）至于为什么，后面讲）（这里不讲是因为和后面函数对应）

2. 内存扩容

这里的newcapacity是给capacity扩容

int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;

这里的ps->capacity*2跟上面的capacity置为4相对应，如果capacity置为0，那么0*2还是0，无法扩容，导致这个顺序表大小只有4，为什么只有4，原因在ps->capacity == 0 ? 4

if语句是判断realloc会不会申请内存失败（一般是不会的，但是为了安全性还是必须写的）

最后我们直接把 tmp 接收申请好的内存数组赋给a

再把newcapacity扩容好的值赋给capacity

这里会有点难理解需要读者慢慢消化

3.顺序表头部插入

这里需要注意头部插入和尾部插入的顺序可以颠倒

但是在第一个插入的函数必须直接让扩容函数直接执行，让ps->a申请内存，不然ps->a为空，无法进行插入会直接报错

代码思路：

让end放在有效数据的前一个数字（简单来说就是让end放在顺序表最后一个位置，向前走，分别想换他们的位置）

while end>=0是判断到数组开头的数据移动后一位，为要插入的数据腾出空间

ps->a[end+1]=ps->a[end]

把最后一个数据移动到size这个为空的有效位置

移动完后让end往前走（++是往后走 --是往前走）

循环结束后所有的数据都往后移动了一个位置

再把 x （就是你想插入的数据）插入到第一个位置 a[0]就是数组的第一个位置

再让size++ 有效数据有多了一个

4.顺序表的尾部插入

这是第二次插入不能让扩容直接进入，需要判断有效数据是否达到了容量大小

如果达到就扩容，没达到就无需扩容。

尾部插入比较简单

因为size本身就指向有效数据的后一位，我们直接在size这里添加，再让size往后移一下，就完成了尾部插入。

5.顺序表的头部删除

int end =1 让end放在数组的第二个位置（数组0是第一个位置所以1是第二个位置）

while (end < ps->size)第二位置开始一直到最后的有效数据

先把数组第二的位置覆盖到数组第一个位置然后就删除了

但是数组第二个位置就为空了让第三个数据覆盖上来

但是数组第三个位置就为空了让......依次类推

++end就是让end往后走持续交换

ps->size-- 有效数据少一个所以size要--

6.顺序表的尾部删除

因为是尾部删除而size也是指向有效个数，直接让size--就等于删除了最后一个数据，就是尾部删除了

7.在特定位置插入

只要是插入数据我们都要进行判断容量的大小是否满了

让end放在size的前一位

把最后一个数据往后移动

让end--（往前移动）

while (end < ps->size)直到pos这个位置的数据也往后移动一位

循环结束后pos后面的数据包括pos这个位置的数据都往后移动了一位，pos这个位置是空数据，为插入的数据腾出了空间我们直接插入就可以了

（注意 pos 是数组小标位置不是数据为几例如 0 ，1就是数组的第一个和第二个，而不是数字0，1）

size++ 有效数据插入一个就++

8.在特定位置删除数据

这个函数原理跟头部删除差不多

它是在pos的后一位数据的位置往前覆盖，而头部删除是在头部数据的后一位往前覆盖

9.打印顺序表

这里直接让i从0开始一直到size这里的有效数据都打印一边就可以了。

10.释放申请的动态内存

我们把指针释放再置为空

然后把有效数据和容量大小都置为0

所有函数功能就实现了

下面是代码（需要可以自取）

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

//以后要用到顺序表不一定是用到 int 类型 如果要该类型非常麻烦需要一个个改
//给类型重命名 以后需要用到哪种类型 直接在这里改就可以了 更加方便
typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* a;//指向动态开辟数组的指针
	int size;//有效的数据个数
	int capacity;//容量的大小
}SeqList;

//初始化
void SeqListInit(SeqList* ps)
{
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 4;
}

void Expand(SeqList* ps)
{
	int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
	SLDataType* tmp = (SLDataType*)realloc(ps->a, ps->capacity * sizeof(SLDataType));  
	if (tmp == NULL)
	{
		printf("realloc fail");
		exit(-1);
	}
	else
	{
		ps->a =tmp;
		ps->capacity = newcapacity;
	}
}


//顺序表的头部插入元素
void SeqListPushBack(SeqList* ps, SLDataType x)
{
	//第一次进行插入 的时候 不管是头 尾 插入 都必须直接进入扩容阶段 
		Expand(ps);
		int end = ps->size - 1;
		while (end >= 0)
		{
			ps->a[end + 1] = ps->a[end];
			--end;
		}
		ps->a[0] = x;
		ps->size++;
}

void SeqListPushFront(SeqList* ps, SLDataType x)
{
	if (ps->size == ps->capacity)
	{
		Expand(ps);
	}
	ps->a[ps->size] = x;
	ps->size++;
}


void SeqListPrint(SeqList* ps)
{
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
}

void SeqListDestory(SeqList* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

void SeqListPopBack(SeqList* ps)
{
	int end = 1;
	while (end < ps->size)
	{
		ps->a[end - 1] = ps->a[end];
		end++;
	}
	ps->size--;
}

void SeqListPopFront(SeqList* ps)
{
	assert(ps->size > 0);

	ps->size--;
}

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

//pos不是0这个数字 在现在的元素里是没有0这个数的 0表示的是数组下标
void SeqListInsert(SeqList* ps, int pos, SLDataType x)
{
	if (ps->size == ps->capacity)
	{
		Expand(ps);
	}
	int end = ps->size-1;
	while (end >= pos)
	{
		ps->a[end +1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}

void SeqListErase(SeqList* ps, int pos)
{
	int end = pos + 1;
	while (end < ps->size)
	{
		ps->a[end - 1] = ps->a[end];
		++end;
	}
	ps->size--;
}

void Inteliode()
{
	SeqList st;
	//void SeqListInit(SeqList* ps);
	SeqListInit(&st);
	//void SeqListDestory(SeqList* ps);

	//void SeqListPrint(SeqList* ps);
	
	//void SeqListPushBack(SeqList* ps, SLDateType x);
	SeqListPushBack(&st, 5);
	SeqListPushBack(&st, 4);
	SeqListPushBack(&st, 3);
	SeqListPushBack(&st, 2);
	SeqListPushBack(&st, 1);
	//void SeqListPushFront(SeqList* ps, SLDateType x);
	SeqListPushFront(&st, 6);
	SeqListPushFront(&st, 7);
	SeqListPushFront(&st, 8);
	SeqListPushFront(&st, 9);
	SeqListPushFront(&st, 10);
	//void SeqListPopFront(SeqList* ps);
	SeqListPopFront(&st);
	SeqListPopFront(&st);
	SeqListPopFront(&st);
	//void SeqListPopBack(SeqList* ps);
	SeqListPopBack(&st);
	SeqListPopBack(&st);
	SeqListPopBack(&st);
	 顺序表查找
	//int SeqListFind(SeqList* ps, SLDateType x);
	int pos=SeqListFind(&st, 4);
	SeqListInsert(&st, 0, 50);
	这里的5不是说数字5 而是数组下标
	SeqListErase(&st, 0);
	 顺序表在pos位置插入x
	//void SeqListInsert(SeqList* ps, size_t pos, SLDateType x);
	 顺序表删除pos位置的值
	//void SeqListErase(SeqList* ps, size_t pos);
	SeqListPrint(&st);
	SeqListDestory(&st);
}


int main()
{
	Inteliode();

	return 0;
}

有问题可以发表评论。