顺序表

顺序表基本概念

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组
上完成数据的增删查改。
顺序表一般可以分为：
1. 静态顺序表：使用定长数组存储。
2. 动态顺序表：使用动态开辟的数组存储。

顺序表静态存储

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

顺序表动态存储

typedef struct SeqList
{
 SLDataType* array; // 指向动态开辟的数组
 int size ; // 有效数据个数
 int capicity ; // 容量空间的大小
}SeqList;

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以我们实现动态顺序表。

顺序表的定义

typedef int SLDataType;

typedef struct SeaList{
	SLDataType *array;   //保存指向堆上的空间的地址
	SLDataType capacity;//数组容量
	SLDataType size;  //有效数据个数
} SeqList;

初始化

void SeqListInit(SeqList *ps){
	ps->capacity = 10;
	ps->array = (int *)malloc(sizeof(SLDataType)*ps->capacity);
	ps->size = 0;
}

销毁

void SeqListDestory(SeqList *ps){
	free(ps->array);
	ps->array = NULL;
	ps->capacity = 0;
	ps->size = 0;
}

打印

void SeqListPrint(SeqList *ps){
	for (int i = 0; i < ps->size; i++)
	{
		printf("  %d", ps->array[i]);
	}
}

尾插

void SeqListPushBack(SeqList *ps, SLDataType value) {
	ps->array[ps->size] = value;
	ps->size++;
}

头插

void SeqListPushFront(SeqList *ps, SLDataType value){
	//先将已有数据后移一位
	for (int i = ps->size; i >= 1; i--) {
		ps->array[i] = ps->array[i - 1];
	}
	ps->array[0] = value;
	ps->size++;
}

按下标插入

void SeqListInsert(SeqList *ps, int pos, SLDataType value){
	//pos[0,size]
	if (pos<0 || pos>ps->size){
		printf("超出范围\n");
	}
	//i是数据的下标
	for (int i = ps->size - 1; i >= pos; i--){
		ps->array[i + 1] = ps->array[i];
	}
	ps->array[pos] = value;
	ps->size++;

}

尾删

void SeqListPopBack(SeqList *ps){
	assert(ps->size > 0);
	ps->size--;
}

头删

void SeqListPopFront(SeqList *ps){
	assert(ps->size > 0);
	for (int i = 0; i <= ps->size - 2; i++) {
		ps->array[i] = ps->array[i + 1];
	}
	ps->size--;
}

按下标删除

void SeqListErase(SeqList *ps, int pos){
	assert(ps->size > 0);
	for (int i = pos + 1; i <= ps->size; i++){
		ps->array[i - 1] = ps->array[i];
	}
	ps->size--;
}

查找value的下标

int SeqListSearch(const SeqList* ps, SLDataType value){
	for (int i = 0; i < ps->size; i++){
		if (ps->array[i] == value){
			return i;
		}
	}
}

删除遇到的第一个value

void SeqListRemove(SeqList * ps, SLDataType value){
	int pos = SeqListSearc(ps, value);
	if (pos != -1){
		SeqListErase(ps,pos);
	}
}

删除所有的value

void SeqListRemoveAll(SeqList* ps, SLDataType value){
	int i, j;
	for (i = 0, j = 0; i < ps->size; i++){
		if (ps->array[j] != value){
			ps->array[j] = ps->array[i];
			j++;
		}
	}
	ps->size = j;
}

获取顺序表有效元素个数 

int SeqListSize(SeqList* ps){
	return ps->size;
}

获取顺序表的容量 

int SeqListCapacity(SeqList* ps){
	return ps->capacity;
}

检测顺序表是否为空 

int SeqListEmpty(SeqList* ps){
	if (ps->size == 0){
		return 1;
	}
	else return 0;
}

获取顺序表中第一个元素 
 

DataType SeqListFront(SeqList* ps){
	return ps->array[0];
}

 获取顺序表中最后一个元素 

DataType SeqListLast(SeqList* ps){
	return ps->array[ps->size-1];
}