顺序表实现增删查改

本文摘要：

1.顺序表的概念

2.顺序表结构的定义

3.动态顺序表的操作实现

 

顺序表的概念

顺序表是一种数据结构，是数据的存储方式。

顺序表是改善了数组的缺点，相对增加了灵活性，使用户能够实现增删查改的操作。

顺序表分为静态顺序表和动态顺序表。

                        

顺序表的定义

//静态顺序表
#define N 100
typedef int STDataType;

typedef struct StaticSeqList{
    STDataType arr[N];    //给定数组大小
    size_t size;        //顺序表的大小
    
}StaticSeqList;

//动态顺序表

typedef struct SeqList{
    STDataType* arr;
    size_t size;        //有效元素个数
    size_t capacity;    //顺序表的容量
};

动态顺序表的操作实现

一般对数据的操作有增删查改，初始化和销毁，因为生活中动态顺序表的使用场景较多，这里只实现对动态顺序表的管理。

在对顺序表的操作过程中，要注意两点：

1.添加数据时判断顺序表是否需要增容，否则会发生数组越界。

2.删除数据时，要检查顺序表是否为空.

3.顺序表大小psl->size和数组psl->arr的大小关系：顺序表中第size个数对应的数组为psl->arr[psl->size - 1].

 

增加数据：每次操作顺序表大小加一

每次增加数据时都要检查函数容量是否够用

                         

//尾插
void SeqListPushBcak(SeqList* psl, STDataType x){
	assert(psl);

    SeqListCheckCapacity(&s1);
	psl->arr[psl->size] = x;
	psl->size++;
	
	return;
}

//头插
void SeqListPushFront(SeqList* psl, STDataType x){
	assert(psl);
    
    SeqListCheckCapacity(&s1);
	size_t i = psl->size;
	for (; i > 0; i--);
		psl->arr[i + 1] = psl->arr[i];

	psl->arr[0] = x;
	psl->size++;
}

//	在指定位置插入，然后将其后面的数依次往后。
void SeqListInsert(SeqList* psl, size_t pos, STDataType x){
	assert(psl);
    
    SeqListCheckCapacity(&s1);
	size_t end = psl->size;
	if (pos == end){
		psl->arr[pos] = x;
		psl->size++;
	}
	else if (pos < psl->size){
		size_t i = psl->size;
		while (pos < i){
			psl->arr[i] = psl->arr[i - 1];
			i--;
		}
		psl->arr[pos - 1] = x;
		psl->size++;
	}
}

删除操作：每次操作顺序表大小减一

每次

                                  

//删除任意位置的数
void SeqListErase(SeqList* psl, size_t pos){
	assert(psl);

	//pos在数组中是下一个数,删除之后，依次往前挪。
	//pos 和 psl->size 的大小一致
	if (pos == psl->size){
		psl->size--;
	}
	else if (pos < psl->size){
		size_t i = pos;
		while (i < psl->size){
			psl->arr[i - 1] = psl->arr[i];
			i++;
		}
		psl->size--;
	}
}

//头删
void SeqListPopFront(SeqList* psl){
	assert(psl);

	//一次往前挪其他元素。
	size_t i;
	for (i = 0; i < psl->size; i++){
		psl->arr[i] = psl->arr[i + 1];
	}
	psl->size--;
}

//尾删
void SeqListPopBack(SeqList* psl){
	assert(psl);

	//只需要将大小减一就可以了
	psl->size--;
}

查找某个数：

                            

//查找某个数的位置
int SeqListFind(SeqList* psl, STDataType x){
	assert(psl);

	//遍历顺序表中的，size的大小可以作为边界
	size_t i = 0;
	while (i < psl->size){
		if (psl->arr[i] == x)
			return i + 1;
		else
			i++;
	}
	return -1;	//没找到
}

修改数据：

初始化顺序表：

//初始化顺序表
void SeqListInit(SeqList* psl, size_t capacity){
	assert(psl);

	psl->arr = (STDataType*)malloc(capacity*sizeof(STDataType));
	psl->size = 0;
	psl->capacity = capacity;

	return;
}

//检查容量是否够用
void SeqListCheckCapacity(SeqList* psl){
	assert(psl);

	//每一个增容函数都要用到Checkcapacity函数
	if (psl->size == psl->capacity){	//容量和有效元素大小相同，不能再存放函数，故增容
		//但要检查函数是否为空链表
		if (psl->capacity == 0){
			psl->capacity = 2;
		}
		else{
			//先使用临时变量先来保存扩容后的空间指针
			STDataType* tmp = (STDataType*)realloc(psl->arr, 2 * psl->capacity*sizeof(STDataType));
			//realloc 的第二个参数是字节大小
			assert(tmp);
			psl->arr = tmp;
			psl->capacity *= 2;

		}
	}
}

销毁顺序表：

//销毁顺序表
void SeqListDestroy(SeqList* psl){
	assert(psl);

	psl->arr = NULL;
	psl->size = 0;
	psl->capacity = 0;

	return;
}