顺序表的各类接口实现

顺序表的基本操作（增删查改）

1.顺序表的定义

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。
顺序表主要有两种：
1.静态顺序表：定长数组；
2.动态顺序表：动态开辟数组。
顺序表的静态存储：

#define N  xx
typedef int SLDataType;
typedef struct SeqList
{
   SLDataType array[N]; // 定长数组
   size_t size; // 有效数据的个数 
}SeqList;

顺序表的动态存储：

typedef int SLDataType;
typedef struct SeqList
{
  SLDataType* array;
  size_t size;
  size_t capacity;
}SeqList;

2. 顺序表的各种接口实现

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

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* _array;//动态开辟的数组
	size_t _size;//有效数据长
	size_t _capacity;//数组容量
}SeqList;
//顺序表的初始化
void SeqListInit(SeqList* ps, size_t capacity)
{
	assert(ps);
	ps->_array = (SLDataType*)malloc(sizeof(SLDataType)*capacity);
	ps->_size = 0;
	ps->_capacity = capacity;
}
//顺序表的销毁
void SeqListDestory(SeqList* ps)
{
	assert(ps);
	if (ps->_array)
	{
		free(ps->_array);
		ps->_array = NULL;
		ps->_size = 0;
		ps->_capacity = 0;
	}
}
void CheckCapacity(SeqList* ps)
{
	assert(ps);
	if (ps->_capacity == ps->_size)
	{
		ps->_capacity = ps->_capacity * 2;
		ps->_array = realloc(ps->_array, ps->_capacity*sizeof(SLDataType));
		assert(ps->_array);//断言申请内存成功
	}
}

void SeqListPushBack(SeqList* ps, SLDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	ps->_array[ps->_size] = x;
	ps->_size++;
}
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	ps->_size--;
}
void SeqListPushFront(SeqList* ps, SLDataType x)//容易不设指针，会造成数据丢失
{
	assert(ps);
	CheckCapacity(ps);
	int end = ps->_size;
	while (end > 0)
	{
		ps->_array[end] = ps->_array[end - 1];
		--end;
	}
	ps->_array[0] = x;
	ps->_size++;
}

void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	size_t begin = 0;
	while (begin < ps->_size)
	{
		ps->_array[begin] = ps->_array[begin + 1];
		begin++;
	}
	ps->_size--;
}
int SeqListFind(SeqList* ps, SLDataType x)
{
	assert(ps);
	for (size_t i = 0; i < ps->_size; ++i)
	{
		if (ps->_array[i] == x)
			return i;
	}
	printf("找不到此数字");
}
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	size_t end = ps->_size;
	while (end>pos)
	{
		ps->_array[end] = ps->_array[end-1];//end已经是最后一个了，用end-1会防止出现越栈问题
		end--;
	}
	ps->_array[pos] = x;
	ps->_size++;
}
void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps);
	size_t begin = pos;
	while (begin < ps->_size)
	{
		ps->_array[begin] = ps->_array[begin+1];
		begin++;
	}
	ps->_size--;
}

void SeqListRemove(SeqList* ps, SLDataType x)//相当于一个一个与x进行比对，不是的放入dst数组中；
{
	size_t cur = 0;
	size_t dst = 0;
	while (cur < ps->_size)
	{
		if (ps->_array[cur] != x)
		{
			ps->_array[dst] = ps->_array[cur];
			dst++;
		}
		cur++;
	}
	ps->_size = dst;
}
void SeqListModify(SeqList* ps, size_t pos, SLDataType x)
{
	assert(ps);
	ps->_array[pos] = x;
}

void SeqListPrint(SeqList* ps)
{
	assert(ps);
	for (size_t i = 0; i < ps->_size; i++)
	{
		printf("%d ", ps->_array[i]);
	}
	printf("\n");
}
}

通过实现顺序表的各种接口，我们可以发现顺序表的一些缺点：

1. 中间/头部的插入和删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间，消耗会比较大。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。