数据结构 顺序表

正文开始

1. 什么是数据结构？

在学习顺序表前，我们先来了解一下什么是数据结构：数据结构是计算机存储、组织数据的方式，具有一定逻辑关系，在计算机中应用某种存储结构，并且封装了相应操作的数据元素集合。
例如，我要管理我的书，我可以将它们分类并放在书架的对应位置。书类比数据，书架类比结构，这样我就以这种方式存储、组织起来了我的书。

2. 顺序表

2.1 线性表

线性表是 n 个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表有：顺序表、链表、栈、队列、字符串……
线性表在逻辑上是线性的，也就是能够沿着某一数据找到另一个数据。但在物理结构上并不一定是连续的。
线性表在物理上存储时，通常以数组和链式结构的形式存储。

2.2 顺序表

顺序表是线性表的一种，它的底层是数组，对数组的封装，实现了常用的增删改查等接口。

顺序表分为两种：

• 静态顺序表：使用定长数组存储元素，一旦确定大小，便不能再次修改，所以缺点很大。

typedef int SLDataType;
#define N 10
typedef struct SeqList{
	SLDataType a[N]; //定长数组，存储数据
	int size;        //记录有效数据个数
}SL;

• 动态顺序表：使用动态内存来存储元素，可根据实际情况调整大小。

typedef int SLDataType;
typedef struct SeqList{
	SLDataType* a; //指针，指向存储数据的地方
	               //得以实现改变大小
	int size;      //记录有效数据个数
	int capasity;  //记录实际空间大小
}SL;

动态顺序表并非创建了一个数组来存储数据，而是通过指向一块可支配空间来存储数据，这样就可以通过动态内存管理的方式来改变空间的大小，实现了按需分配内存。

而静态顺序表通过创建一个数组来存储数据，数组的特点是一旦定义完，大小不可变，这样就缺少了灵活性，所以推荐使用动态顺序表。

3. 动态顺序表的实现

实现动态顺序表定义了三个文件：

• SeqList.h：用来引用相关操作所需要的头文件，定义顺序表结构，声明相关操作的函数。
• SeqList.c：用来实现相关操作的函数。
• test.c：对顺序表的各种操作函数进行测试。

SeqList.c：

#include "SeqList.h"
//实现顺序表功能

//初始化
void SLInit(SL* ps)
{
	assert(ps);
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}
//销毁
void SLDestroy(SL* ps)
{
	assert(ps);
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}
//打印
void SLPrint(SL s)
{
	for (int i = 0; i < s.size; i++)
	{
		printf("%d ", *(s.arr + i));
	}
	printf("\n");
}
//检查是否空间足够
void SLCheckCapacity(SL* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		//若空间为0，则给定空间大小为4；若不为零，则空间大小翻倍
		int NewCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, sizeof(SLDataType) * NewCapacity);
		if (tmp == NULL)
		{
			perror("realloc");
		}
		ps->arr = tmp;
		ps->capacity = NewCapacity;
	}
}
//尾插
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	ps->arr[ps->size++] = x;
}

//头插
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];
	}
	ps->arr[0] = x;
	ps->size++;
}
//尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);
	ps->size--;
}
//头删
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size);
	for (int i = 0; i < ps->size; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size++;
}
//指定位置之前插入
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}
//指定位置之前删除
void SLErase(SL* 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--;
}
//查找某元素
int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			printf("找到%d啦，下标为%d\n", x, i);
			return i;
		}
	}
	printf("没有找到%d\n",x);
	return -1;
}

SeqList.h：

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//定义顺序表并声明操作函数

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType * arr;
	int size;//有效数据个数
	int capacity;//空间大小
}SL;

//顺序表初始化
void SLInit(SL* ps);

//顺序表的销毁
void SLDestroy(SL* ps);

//顺序表的打印
void SLPrint(SL s);

//检查空间是否足够
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);

test.c：

#include "SeqList.h"

//测试功能
SL SQ;
void Test01()
{
	SLInit(&SQ);
	SLPushBack(&SQ, 7);
	SLPushBack(&SQ, 6);
	SLPushBack(&SQ, 5);
	SLPrint(SQ);
	SLPushFront(&SQ, 4);
	SLPushFront(&SQ, 3);
	SLPrint(SQ);
	SLInsert(&SQ, 4, 2);
	SLInsert(&SQ, 2, 1);
	SLPrint(SQ);
	SLErase(&SQ, 5);
	SLErase(&SQ, 4);
	SLPrint(SQ);
	SLFind(&SQ, 7);
	SLFind(&SQ, 9);
}
int main()
{
	Test01();
	return 0;
}

测试文件执行结果：