C语言实现一个简单动态顺序表

1. 什么是线性结构？ 线性结构中都包含什么内容？

线性表是n个具有相同特征的数据元素的有限序列。常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，就是一条连续直线，但在物理结构上不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

2.什么是顺序表？顺序表的分类？

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，通常采用数组存储
顺序表通常分为静态顺序表和动态顺序表，
静态顺序表：使用定长数组存储
动态顺序表：使用动态开辟的数组存储

在数组上完成增删改查操作

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <assert.h>

typedef int DataType; //方便修改顺序表类型；
typedef struct SeqList
{
	DataType* _array;
	int _capacity;  //顺序表的总大小
	int _size;  //顺序表中的有效元素个数
}SeqList,*PSeq;

//typedef struct SeqList SeqList
//typedef struct SeqList *pSeqList

//顺序表的初始化
void SeqListInit(PSeq ps, int capacity)
{
	ps->_capacity = capacity;
	ps->_array = (DataType*)malloc(sizeof(DataType)* ps->_capacity);
	if (ps->_array == NULL)
	{
		assert(0);
	}
	ps->_size = 0;
}

void swap(int* x, int * y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

int Checkcapacity(PSeq ps)
{
	assert(ps != NULL);
	if (ps->_size <= ps->_capacity)
	{
		return 1;
	}
	return 0;
}
// 在顺序表的尾部插入值为data的元素 
void SeqListPushBack(PSeq ps, DataType data)
{	
	assert(ps!=NULL);
	if(Checkcapacity(ps))
	{ 
		ps->_array[ps->_size] = data;
		ps->_size++;
	}
}
// 删除顺序表最后一个元素 
void SeqListPopBack(PSeq ps)
{
	assert(ps != NULL);
	if (ps->_size > 0)
	{
		ps->_array[ps->_size - 1] = 0;
		ps->_size--;
	}
}

// 在顺序表的头部插入值为data的元素 
void SeqListPushFront(PSeq ps, DataType data)
{
	assert(ps != NULL);
	for (int i = ps->_size; i > 0; --i)
	{
		swap(&(ps->_array[i]), &(ps->_array[i - 1]));
	}
	ps->_array[0] = data;
	ps->_size++;
}

// 删除顺序表头部的元素 
void SeqListPopFront(PSeq ps)
{
	assert(ps != NULL);
	for (int i = 0; i < (ps->_size-1); ++i)
	{
		swap(&(ps->_array[i]), &(ps->_array[i + 1]));
	}
	ps->_size--;
}
// 在顺序表pos位置插入值为data的元素 
void SeqListInsert(PSeq ps, int pos, DataType data)
{
	assert(ps != NULL);
	for (int i = ps->_size; i > pos; --i)
	{
		swap(&(ps->_array[i]), &(ps->_array[i - 1]));
	}
	ps->_array[pos] = data;
	ps->_size++;
}

// 删除顺序表中pos位置上的元素 
void SeqListErase(PSeq ps, int pos)
{
	assert(ps != NULL);
	for (int i = pos; i < ps->_size-1; ++i)
	{
		swap(&(ps->_array[i]), &(ps->_array[i + 1]));
	}
	ps->_size--;
}

// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的下标，否则返回-1 
int SeqListFind(PSeq ps, DataType data)
{
	assert(ps != NULL);
	for (int i = 0; i < ps->_size; ++i)
	{
		if (ps->_array[i] == data)
		{
			return i;
		}
	}
	return -1;
}
// 检测顺序表是否为空，如果为空返回非0值，非空返回0 
int SeqListEmpty(PSeq ps)
{
	assert(ps != NULL);
	if (!ps->_size)
	{
		return 1;
	}
	return 0;
}

// 返回顺序表中有效元素的个数 
int SeqListSize(PSeq ps)
{
	assert(ps != NULL);
	return ps->_size;
}

// 返回顺序表的容量大小 
int SeqListCapacity(PSeq ps)
{
	assert(ps != NULL);
	return ps->_capacity;
}

// 将顺序表中的元素清空 
void SeqListClear(PSeq ps)
{
	assert(ps != NULL);
	ps->_size = 0;
}

// 删除顺序表中第一个值为data的元素 
void SeqListRemove(PSeq ps, DataType data)
{
	assert(ps != NULL);
	int fid = SeqListFind(ps, data);
	SeqListErase(ps, fid);
}

// 销毁顺序表 
void SeqListDestroy(PSeq ps)
{
	 assert(ps != NULL);
	 ps->_capacity = 0;
	 ps->_size = 0;
	 free(ps->_array);
	 ps->_array = NULL;
}

// 顺序表的扩容 
void CheckCapacity(PSeq ps)
{
	assert(ps != NULL);
	int *p = NULL;
	p = (DataType*)realloc(ps->_array, ps->_capacity * 2);
	if (p != NULL)
	{
		ps->_array = p;
		printf("申请内存成功\n");
	}
	ps->_capacity = ps->_capacity * 2;
}
int main()
{
	SeqList ps;
	SeqListInit(&ps,10);
	SeqListPushBack(&ps, 1);
	SeqListPushBack(&ps, 2);
	SeqListPushBack(&ps, 3);
	SeqListPushBack(&ps, 4);
	SeqListPushBack(&ps, 5);
	SeqListErase(&ps, 2);
	SeqListInsert(&ps, 2, 6);
	SeqListPopFront(&ps);
	SeqListPopFront(&ps);
	SeqListRemove(&ps, 4);
	SeqListPushFront(&ps, 8);
	SeqListPopBack(&ps);
	int a = SeqListSize(&ps);
	int b = SeqListCapacity(&ps);
	for (int i = 0; i < (&ps)->_size; ++i)
	{
		printf("%d ", (&ps)->_array[i]);
	}
	printf("\n");
	printf("%d\n", a);
	printf("%d\n", b);
	CheckCapacity(&ps);
	b = SeqListCapacity(&ps);
	printf("%d\n", b);
	SeqListDestroy(&ps);
	system("pause");
	return 0;
}