数据结构之顺序表

顺序表是一段由物理地址连续的存储单元 依次存储数据元素的线性结构，一般情况下 采用数组存储，在数组上完成增删查改 顺序表分为静态和动态，静态的顺序表使用的是定长数组存储， 而动态顺序表使用动态开辟的数组存储， 生活中大多数情况下使用的是动态顺序表 ，下面讲解动态顺序表的增删查改：

#include<stdio.h>
#include<windows.h>
#include<assert.h>

//先定义一个顺序表

typedef struct seqlist{
	int* arr;
	int size;
	int capacity;
}seqlist;

//1.打印所生成的顺序表

void seqlistprint(seqlist* ps){
	if (ps -> size == 0)
	{
		return;
	}
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d\n", ps->arr[i]);
	}

}

//2.顺序表的扩容

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->arr[i];
	}
	free(ps->arr);
	ps->arr =newarray ;
	 ps->capacity=newcapacity;
}

//3.顺序表的初始化

void seqlistinit(seqlist* ps,int capacity){
	assert(ps != NULL);
	if (ps != NULL){
		ps->arr = (int*)malloc(sizeof(int)*capacity);
		assert(ps!=NULL);
		ps->size = 0;
		ps->capacity = capacity;
	}
}

//4.销毁顺序表

void seqlistdestory(seqlist* ps)
{
	assert(ps != NULL);
	free(ps->arr);
}

//5.头插

void seqlistpushfront(seqlist* ps,int v){
	checkcapacity(ps);//这个ps代表地址
	for(int i = ps->size-1; i >=0; i--)
	{
		ps->arr[i + 1] = ps->arr[i];
	}
	ps->arr[0] = v;
	ps->size++;
}

//6.尾插

void seqlistpushback(seqlist* ps,int v){
	checkcapacity(ps);
	ps->arr[ps->size] = v;
	ps->size++;
}

//7.在任意pos下标处插入

void seqlistinsert(seqlist* ps,int pos,int v){
	checkcapacity(ps);
	assert(pos >= 0 && pos < ps->size);
	for (int i = ps->size-1; i >= pos; i--){
		ps->arr[i + 1] = ps->arr[i];
	}
	ps->size++;
	ps->arr[pos] = v;
}

//8.尾删

void seqlistpopback(seqlist* ps){
	assert(ps->size>0);
	ps->size--;
}

//9.头删

void seqlistpopfront(seqlist* ps){
	assert(ps->size > 0);
	for (int i=0; i<=ps->size - 2; i++){
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

//10.在任意pos下标处删除

void seqlisterase(seqlist* ps, int pos){
	assert(pos >= 0 && pos < ps->size);
	for (int i = pos; i <= ps->size - 2; i--)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

//11.查找某一元素在顺序表中的位置并返回下标，找到返回1，没找到返回-1

int seqlistfind(seqlist* ps, int v){
	assert(ps->size>0);
	for (int i = 0; i < ps->size; i++){
		if (ps->arr[i] = v){
			return i;
		}
	}
	return -1;
}

//12.修改指定位置的元素

void seqlistmodify(seqlist* ps, int v, int pos){
	assert(pos >= 0 && pos < ps ->size);
	ps->arr[pos] = v;
	return 1;
}

//13.删除第一个值为v的元素

void seqlistremove(seqlist* ps, int v){
	int dis = seqlistfind(ps, v);
	if (dis = -1){
		return;
	}
	seqlisterase(ps, dis);
}

//14.删除所有值为v的元素

void seqlistremoveall(seqlist* ps, int v)
{
	assert(ps->size > 0);
	int count = 0;

	for ( int i = 0; i < ps->size; i++){
		if (ps->arr[i] = v){
			count++;
			continue;
		}
		ps->arr[i - count] = ps->arr[i];//这个函数的核心代码o(1)
	}
	ps->size - count;
}