数据结构——顺序表

一.顺序表的概念

线性表是n个具有相同特性的数据元素的有限序列。 线性表是⼀种在实际中广泛使
用的数据结构，而顺序表就是一种线性表，常见线性表还有链表，栈，队列，字符串等。

线性表在逻辑上是线性结构，也就是说是连续的一条直线。但是在物理结构上并不一定是连续的，
线性表在物理上存储时，通常以数组和链式结构的形式存储。

二.顺序表的分类

顺序表分为动态顺序表和静态顺序表，静态顺序表底层是一个定长数组，不方便进行增加。当数组大小给大了，可能造成空间浪费，数组大小给小了，可能不够用。因此实现顺序表一般实现动态顺序表，动态顺序表可以按需申请空间。

三.顺序表的实现

顺序表需要实现的一些常见的接口（增删改查等）

由于需要修改数组大小，采用动态开辟的方式申请空间。
我们需要知道这个数组能存的数据最多是多少，还需要知道当前存了多少数据。

给出这样的一个结构体

typedef int SLdatatype;    //方便修改数据类型
typedef struct seqlist
{
	SLdatatype* array;     //数组
	size_t size;           //有效数据个数
	size_t capacity;       //空间容量大小
}SL;

需要实现的接口如下

void SLInit(SL* ps);     //初始化
void SLDestory(SL* ps);  //销毁，释放内存
void SLaddcapacity(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, size_t pos, SLdatatype x); //指定位置(pos)插入
void SLerase(SL* ps, size_t pos);  //指定位置(pos)删除
void SLprint(SL* ps);  //打印
size_t SLfind(SL* ps, SLdatatype x);  //查找

打印接口可以不实现，这里只是为了验证其他接口的正确性。
接下来就一步步实现一个顺序表

1.初始化和销毁

//初始化
void SLInit(SL* ps)
{
	ps->array = NULL;
	ps->capacity = ps->size = 0;
}
//销毁
void SLDestory(SL* ps)
{
	free(ps->array);
	ps->array = NULL;
}

2.插入

插入分为头插和尾插，尾插比较容易实现，只需要根据下标进行插入即可。

头插需要将数据向后移动一位，在进行插入，因此头插的消耗比较大。

//扩容
void SLaddcapacity(SL* ps)
{
	//修改容量大小，一次扩大2倍或1.5倍较为合适
	size_t newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
	//开辟新空间，可能开辟失败，为了保留原有的数据，需要定义一个新的变量
	SLdatatype* temp = (SLdatatype*)realloc(ps->array, newcapacity * sizeof(SLdatatype));
	
	if (temp == NULL)
	{
		perror("realloc failed");
		exit(-1);
	}
	ps->array = temp;   //修改指针
	ps->capacity = newcapacity;  //修改容量大小
}
//尾插
void SLpushback(SL* ps, SLdatatype x)
{
	//不能传空指针
	assert(ps);
	//容量不够，扩充容量
	if (ps->capacity == ps->size) //容量大小和数据个数相等
	{
		SLaddcapacity(ps);
	}
	//插入数据修改size(数据个数)
	ps->array[ps->size] = x;
	ps->size++;
}
//头插
void SLpushfront(SL* ps, SLdatatype x)
{
	//不能传空指针
	assert(ps);
	//容量不够，扩充容量
	if (ps->capacity == ps->size)
	{
		SLaddcapacity(ps);
	}
	//将数据往后移动
	for (size_t i = ps->size; i > 0; i--)
	{
		ps->array[i] = ps->array[i - 1];
	}
	//插入数据，修改size
	ps->array[0] = x;
	ps->size++;
}

头插时，需要从最后一个数据开始，依次向后移动数据。

3.删除

也分为头删和尾删，删除其实就是数据的覆盖。尾删只需要修改一下数据个数即可。

//尾删
void SLpopback(SL* ps)
{
	assert(ps);
	//有数据，才能删除
	assert(ps->size > 0);

	ps->size--;
}
//头删
void SLpopfront(SL* ps)
{
	//不能传空指针
	assert(ps);
	//必须有数据，才能删除
	assert(ps->size > 0);
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->array[i] = ps->array[i + 1];
	}
	ps->size--;
}

头删：从第二个数据开始依次向前移动。

4.任意位置插入和删除

任意位置的插入和删除需要注意插入和删除的位置需要合理，和头插，头删类似。任意位置的插入也是先移动数据在进行插入数据。任意位置的删除也是覆盖数据，不一样的只是移动次数减少了。

//任意位置的插入
void SLinsert(SL* ps, size_t pos, SLdatatype x)
{
	assert(ps);
	//插入位置需要合法
	assert(pos >= 0 && pos <= ps->size);
	//容量如果不够，需要扩充容量
	if (ps->capacity == ps->size)
	{
		SLaddcapacity(ps);
	}
	//移动数据
	for (size_t i = ps->size; i > pos; i--)
	{
		ps->array[i] = ps->array[i - 1];
	}
	ps->array[pos] = x;
	ps->size++;
}
//任意位置的删除
void SLerase(SL* ps, size_t pos)
{
	//不能传空指针
	assert(ps);
	//删除位置需要合法
	assert(pos >= 0 && pos < ps->size);

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

5.查找

查找数据，只需要依次比对。

size_t SLfind(SL* ps, SLdatatype x)
{
	assert(ps);
	for (size_t i = 0; i < ps->size; i++)
	{
		if (ps->array[i] == x)
		{
			return i;
		}
	}
	return -1;
}

四.完整代码

seqlist.h文件

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

typedef int SLdatatype;
typedef struct seqlist
{
	SLdatatype* array;        
	size_t size;           //有效数据个数
	size_t capacity;       //空间容量大小
}SL;

void SLInit(SL* ps);
void SLDestory(SL* ps);
void SLaddcapacity(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, size_t pos, SLdatatype x);
void SLerase(SL* ps, size_t pos);
void SLprint(SL* ps);
size_t SLfind(SL* ps, SLdatatype x);

seqlist.c文件

#define _CRT_SECURE_NO_WARNINGS 1
#include"seqlist.h"
//初始化
void SLInit(SL* ps)
{
	ps->array = NULL;
	ps->capacity = ps->size = 0;
}
//销毁
void SLDestory(SL* ps)
{
	free(ps->array);
	ps->array = NULL;
}
//扩容
void SLaddcapacity(SL* ps)
{
	//修改容量大小
	size_t newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
	//开辟新空间
	SLdatatype* temp = (SLdatatype*)realloc(ps->array, newcapacity * sizeof(SLdatatype));
	if (temp == NULL)
	{
		perror("realloc failed");
		exit(-1);
	}
	ps->array = temp;
	ps->capacity = newcapacity;
}
//尾插
void SLpushback(SL* ps, SLdatatype x)
{
	//不能传空指针
	assert(ps);
	//容量不够，扩充容量
	if (ps->capacity == ps->size)
	{
		SLaddcapacity(ps);
	}
	//插入数据修改size
	ps->array[ps->size] = x;
	ps->size++;
}
//头插
void SLpushfront(SL* ps, SLdatatype x)
{
	//不能传空指针
	assert(ps);
	//容量不够，扩充容量
	if (ps->capacity == ps->size)
	{
		SLaddcapacity(ps);
	}
	//将数据往后移动
	for (size_t i = ps->size; i > 0; i--)
	{
		ps->array[i] = ps->array[i - 1];
	}
	//插入数据，修改size
	ps->array[0] = x;
	ps->size++;
}
//尾删
void SLpopback(SL* ps)
{
	assert(ps);
	//有数据，才能删除
	assert(ps->size > 0);

	ps->size--;
}
//头删
void SLpopfront(SL* ps)
{
	//不能传空指针
	assert(ps);
	//必须有数据，才能删除
	assert(ps->size > 0);
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->array[i] = ps->array[i + 1];
	}
	ps->size--;
}
//任意位置的插入
void SLinsert(SL* ps, size_t pos, SLdatatype x)
{
	assert(ps);
	//插入位置需要合法
	assert(pos >= 0 && pos <= ps->size);
	//容量如果不够，需要扩充容量
	if (ps->capacity == ps->size)
	{
		SLaddcapacity(ps);
	}
	//移动数据
	for (size_t i = ps->size; i > pos; i--)
	{
		ps->array[i] = ps->array[i - 1];
	}
	ps->array[pos] = x;
	ps->size++;
}
//任意位置的删除
void SLerase(SL* ps, size_t pos)
{
	//不能传空指针
	assert(ps);
	//删除位置需要合法
	assert(pos >= 0 && pos < ps->size);

	for (size_t i = pos; i < ps->size-1; i++)
	{
		ps->array[i] = ps->array[i + 1];
	}
	ps->size--;
}
//打印
void SLprint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->array[i]);
	}
	printf("\n");
}
//查找
size_t SLfind(SL* ps, SLdatatype x)
{
	assert(ps);
	for (size_t i = 0; i < ps->size; i++)
	{
		if (ps->array[i] == x)
		{
			return i;
		}
	}
	return -1;
}

顺序表的介绍就到这里了，内容有错误或者适合修改的地方，欢迎大家指出！