数据结构之顺序表(C语言实现)

数据结构之顺序表(C语言实现)

顺序表的介绍

1.顺序表是线性表的一种

2.顺序表的底层是数组，在逻辑上和物理上都是连续的

3.相比于数组，顺序表封装了一些新的操作（增删查改）

4.顺序表分为动态顺序表和静态顺序表，二者的主要区别就在于其中数组空间的申请方式：
静态顺序表的大小是确定的，空间在编译时分配，不易扩容(如下所示)

#define MAX_SIZE 1000
typedef int SLDateType; // 将int 定义为 SLDateType，方便之后替换
typedef struct SeqList
{
	int arr[MAX_SIZE];
	int size;
	int capacity;
}SeqList;

本文将展示动态顺序表的c语言实现方法

coding之前

框架

在阅读源代码过程中，我记录了代码的实现框架：

这样一来，我在复现代码的过程中就不必反复翻看源代码

SeqList.h头文件

如果使用多文件方式实现的话
先新建"SeqList.h"文件, 粘贴以下内容

”SeqList.h"

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

typedef int SLDateType; // 将int 定义为 SLDateType，方便之后替换
typedef struct SeqList
{
	SLDateType* arr;
	int size;
	int capacity;
}SeqList;

// 对数据的管理:增删查改 
void SeqListInit(SeqList* ps); // 注意这里需要传地址
void SeqListDestroy(SeqList* ps);

// 打印顺序表
void SeqListPrint(SeqList* ps);

// 头插、尾插
void SeqListPushBack(SeqList* ps, SLDateType x);
void SeqListPushFront(SeqList* ps, SLDateType x);

// 头删、尾删
void SeqListPopFront(SeqList* ps);
void SeqListPopBack(SeqList* ps);

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

特别注意：函数传参都是传地址
这样我们的任务就变成了在"SeqList.c"文件中实现上述声明的函数

如果不使用多文件，就在同一个文实现这些函数就好了。

理解顺序表结构体

typedef int SLDateType; // 将int 定义为 SLDateType，方便之后替换
typedef struct SeqList
{
	SLDateType* arr;
	int size;
	int capacity;
}SeqList;

将int定义为SLDateType,后续都是用SLDateType作为数据类型。
如果要修改数据类型为float等,只需将typedef 后面的 int 改掉即可
arr是数组首元素的指针，后续会用realloc在这里开辟空间按
size已经存储的数据个数，capacity是已经申请的空间大小（就是目前最多能存储的数据个数）
当size等于capacity时，表明我们需要扩容了

开始编写代码

在"SeqList.c"文件中实现

1.初始化与销毁

初始化和销毁都要将数据空间和有效数据个数设为初始状态，初始化时arr设为空，销毁时释放arr

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


// 销毁
void SeqListDestroy(SeqList* ps)
{
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

再次提醒，函数传参采用传址

打印顺序表

简单直观

// 打印
void SeqListPrint(SeqList* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

检查空间

这是顺序表的关键函数，当capacity与size相等时，说明空间已经不足，需要成倍扩容
这里用newcpacity 去记录新的空间，tmp作为临时变量保存扩容后的空间
注意最后不要忘了赋值给ps->arr, ps->capacity

// 判空，扩容操作
void CheckCapacity(SeqList* ps)
{
	// 判断空间够不够，不够则增容
	if (ps->size == ps->capacity)
	{
		// 若capacity为0给一个默认值，否则倍增
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;

		SLDateType* tmp = (SLDateType*)realloc(ps->arr, newcapacity * sizeof(SLDateType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newcapacity;
	}
}

头插与尾插

我们能在未初始化的野指针上开辟空间，因此需要assert(ps)
调用CheckCapacity函数来扩容
对于尾插直接在末尾添加即可
头插则要将数据整体后移一位，然后在首位置添加
注意最后ps->size需要自增

// 头插
void SeqListPushBack(SeqList* ps, SLDateType x)
{
	assert(ps); // ps 需要初始化

	CheckCapacity(ps);
	ps->arr[ps->size++] = x;
}

//尾插
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	assert(ps); // ps 需要初始化

	// 判空，扩容
	CheckCapacity(ps);
	// 整体后移一位
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;

	ps->size++;
}

头删与尾删

在删除 操作时，由于元素个数为0时不能执行删除操作，所以需要assert(ps->size)
注意不要忘记ps->size的自减

void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size); // 个数为0时不能删除
	
	// 整体前移一位
	for (int i = 1; i < ps->size; i++)
	{
		ps->arr[i - 1] = ps->arr[i];
	}
	ps->size--;
}

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

	ps->size--;
}

按值查找、按位插入、按位删除

这里与前面都是类似的，只需要注意这里的assert区别即可，不在过多赘述

// 后面三个函数跟前面是类似的
int SeqListFind(SeqList* ps, SLDateType x)
{
	assert(ps);

	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

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

void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

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

结语、源码

至此，我们简单实现了动态顺序表，它是线性表的一种，是在数组的基础上封装了更多的便捷的操作。
完整代码可参照：顺序表