数据结构，简单的顺序表该怎么写

数据结构的实际两种结构
1.物理结构 （内存中是如何存储的）
2.逻辑结构 （脑海里想象的）
线性表
物理结构：数组，链表
数组的缺点在于，开辟空间过大，会浪费存储空间，开辟空间过小，满足不了存储的需求。
链表能满足按需索取内存的要求
而链表能满足需求的重点在于指针的使用
前一块空间会存储下一个空间的指针，一节节穿连起来，从而实现遍历
链表选择在堆区申请空间，空间上是非线性的，但逻辑上是线性的。
2.顺序表
顺序表是用物理地址连续的存储单元依次存储的线性结构，一般采用数组存储，并完成增删查改的操作。其实可将顺序表看作数组。

 

SeqList.h
//#pragma once //防止重复包含
顺序表，有效数组在数组中必须是连续的
静态顺序表设计（固定大小）
//typedef int SLDataType;
//#define N 10
//struct SeqList
//{
//	 SLDataType a[N];
//	int size;
//
//};
//void SeqListPushBack(struct SeqList* ps, SLDataType x);
//void SeqListPopBack(struct SeqList* ps);
//void SeqListPushFront(struct SeqList* ps, SLDataType x);
//void SeqListPopFront(struct SeqList* ps);
#pragma once //防止重复包含
//动态顺序表设计（大小可变）
//链表的缺点在于难以随机访问
//顺序表增删查改的主要要求是保持空间足够，保持顺序不变
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLDataType;
#define N 10
typedef struct SeqList
{
	SLDataType* a;
	int size;//有效数据个数
	int capacity;//容量空间大小

}SL,SeqList;
void SeqListInit(SL* ps);
void SeqListDestroy(SL* ps);//malloc开辟的内存空间不会主动销毁
void SeqListCheckCapacity(SL* ps);
//尾插尾删，头插头删
void SeqListPushBack(SL* ps, SLDataType x);
void SeqListPopBack(SL* ps);
void SeqListPushFront(SL* ps, SLDataType x);
void SeqListPopFront(SL* ps);
//任意位置插入删除
void SeqListInsert(SL* ps,int post, SLDataType x);
void SeqListErase(SL* ps, int pos);
//查找
int SeqListFind(SL* ps, SLDataType x);

SeqList.c
#include "SeqList.h"
//   typedef size_t unsigned int 用无符号整型的话，就无需判断post>=0 ，unsinged int 只能为正数
void SeqListInit(SL* ps)//初始化
{
	/*s.size = 0;
	s.a = NULL;
	s.capacity = 0;*/
	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * 4);
	if (ps->a == NULL)
	{
		printf("申请内存失败\n");
		exit(-1);//直接退出
	}
		ps->size= 0;
		ps->capacity = 4;
	
}

void SeqListDestroy(SL*ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

void SeqListCheckCapacity(SL* ps)
{
	if (ps->size >= ps->capacity)
	{
		ps->capacity *= 2;
		ps->a = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->capacity);
		if (ps->a == NULL)
		{
			printf("扩容失败/n");
			exit(-1);
		}
	}




}
void SeqListPrint(SL* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; ++i)
	{
		printf("%d", ps->a[i]);
		
	}
	printf("\n");
}
//尾插尾删，头插头删
void SeqListPushBack(SL* ps, SLDataType x)
{
	SeqListCheckCapacity(ps);
	assert(ps);//指针不能为空
	//如果满了需要增容
	//一般增容选择增二倍，三倍
	
	ps->a[ps->size] = x;//指针访问结构体元素
	ps->size++;
	
//越界一定有问题，没越界不一定没问题



}
void SeqListPopBack(SL* ps)
{
	assert(ps);
	ps->size--;
}
void SeqListPushFront(SL* ps, SLDataType x)
{   
	SeqListCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[0] = x;
	ps->size++;

}
void SeqListPopFront(SL* ps)
{
	assert(ps);
	int start = 0;
	while (start <=ps-> size - 2)
	{
		ps->a[start] = ps->a[start + 1];
		++start;
	}
	ps->size--;

}
//任意位置插入删除
void SeqListInsert(SL* ps, int post, SLDataType x)
{
	assert(ps);
	assert(post <= ps->size&&post>=0);
	SeqListCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= post)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
     }
	ps->a[post] = x;
	ps->size++;
}
void SeqListErase(SL* ps, int post)
{
	assert(post);
	assert(post < ps->size&& post >= 0);
	int start=post;
	while (start <= ps->size - 2)
	{
		ps->a[start] = ps->a[start + 1];
		start++;
		ps->size--;

	}

}
//头插，头删，尾插，尾删，其实可以用insert erase两个接口来实现
int SeqListFind(SL* ps, SLDataType x)
{
	assert(ps);
	int i = 0;
	while (i < ps->size)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
		i++;
	}
	return -1;//表示没找到


}

test.c
#include "SeqList.h"
void TestSeqList1()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPopBack(&s);
	SeqListPushFront(&s,-1);
	SeqListPopFront(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListInsert(&s, 2, 8);
	int post = SeqListFind(&s, 8);
	if (post != -1)
	{
		SeqListErase(&s, post);
	}
	SeqListPrint(&s);
	SeqListDestroy(&s);