DS---顺序表的相关操作

顺序表

顺序表：用一段地址连续的存储单元依次存储数据元素的线性结构

地址连续的空间：一般情况下采用数组，但数组有静态数组和动态数组，

所以顺序表分为：静态顺序表和动态顺序表

首先我们先来看看两种顺序表的结构：

静态顺序表

#define MAX_SIZE 10
typedef int DataType;//int的别名，如此定义方便后期数据类型修改
struct SeqList {
	DataType _array[MAX_SIZE];
	int _size;//顺序表中有效元素的个数
};

动态顺序表

typedef int DataType;
typedef struct SeqList {
	DataType* array;//数据块指针
	int size;//有效数据个数
	int capacity;//容量
}SeqList;

动态顺序表的相关操作

初始化：

void SeqListInit(SeqList *ps, int capacity) {
	assert(ps != NULL);
	if (ps != NULL);
	ps->array = malloc(sizeof(int)*capacity);
	assert(ps->array != NULL);
	ps->size = 0;
	ps->capacity = capacity;
}

销毁：

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

尾插：

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

头插:

void SeqListPushFront(SeqList *ps, int v) {
	//i代表的含义是空间的下标
	for (int i = ps->size; i <= 1; i--) {
		ps->array[i] = ps->array[i - 1];
	}
	ps->array[0] = v;
	ps->size++;
}

指定位置的插入：

//pos=0头插,pos=size尾插
void SeqListInsert(SeqList *ps, int pos, int v) {
	//i数据的下标
	for (int i = ps->size - 1; i >= pos; i--) {
		ps->array[i + 1] = ps->array[i];
	}
	ps->array[pos] = v;
	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--;
}

删除指定位置的元素：

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

}

扩容：

static void CheckCapacity(SeqList *ps) {
	if (ps->size < ps->capacity) {
		return;
	}
	int newCapacity = ps->capacity * 2;
	int *newArray = (int *)malloc(sizeof(int)*newCapacity);
	assert(newArray != NULL);
	
	for (int i = 0; i < ps->size; i++) {
		newArray[i] = ps->array[i];
	}
	free(ps->array);
	ps->array = newArray;
	ps->capacity = newCapacity;
}