C语言简易顺序表(动态内存)

目录:

1. 顺序表的定义

2. 顺序表的初始化

3.顺序表的扩容

4.顺序表的销毁

5.顺序表的尾插

6.顺序表的头插

7.顺序表的头删

8.顺序表的尾删

9.顺序表的打印

10.顺序表的插入

11.顺序表的删除 

12.顺序表的查找        

13.顺序表的修改

顺序表的定义

顺序表是n个具有相同特性的数组元素的有序数列，顺序表在逻辑上是线性结构，也就是一条连续的直线，但在计算机内存中不一定是连续的

typedef int SLDataType;//方便以后使用顺序表存储不同类型数据的值

typedef struct llist
{
    SLDataType* a; //指向动态开辟的数组
    int size;      //有效的数据个数
    int capacity;  //当前顺序表容量大小
}SL;

使用typedef来定义int后 如果以后要存储不同数据类型的值的话就只需要改变typedef 后的 int

---------------------------------------------------------------------------------------------------------------------------------

顺序表的初始化

void SLInit(SL* ps)
{
	assert(ps != NULL);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

也可以在顺序表初始化的时候就开一个大小

顺序表的扩容

void SLcheakcapacity(SL* ps)
{
	if (ps->size == ps->capacity)//当有效数字等于容量的时候 就要扩容了
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;①
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * newcapacity);
		if (tmp == NULL)//一般情况下是不会扩容失败的
		{
			cout << "扩容失败";
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	return;
}

① 当顺序表为空的时候 就开辟容量大小为4(capacity==4) 

 顺序表的销毁

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

 因为存在free空指针的问题 这里要用if判断一下顺序表是否为空 

顺序表的尾插

void SLPushBack(SL* ps, SLDataType x)
{
	SLcheakcapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}

 在插入前要先看看容量够不够 需不需要扩容

顺序表的头插

void SLPushfront(SL* ps, SLDataType x)
{
	SLcheakcapacity(ps);
	for (int i = ps->size; i >= 1; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[0] = x;
	ps->size++;
}

 顺序表不适合头插，头插的时间复杂度为o(n^2)要将数组中整体后移

顺序表的头删

void SLPopfront(SL* ps)
{
	assert(ps->size > 0);
	for (int i = 1; i < ps->size; i++)
	{
		ps->a[i - 1] = ps->a[i];
	}
	ps->size--;
	return;
}

 顺序表的尾删

void SLPopback(SL* ps)
{
	assert(ps->size > 0);
	if (ps->size == 0)//判断顺序表是否为空
	{
		printf("顺序表为空\n");
		return;
	}
	ps->size--;
}

 size记录的是有效数字，所以只需要sp->size--就可以

顺序表的打印

void SLprint(SL* ps)
{
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	return;
}

顺序表的插入

void SLinset(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	SLcheakcapacity(ps);
	int i = ps->size;
	while (i > pos)
	{
		ps->a[i] = ps->a[i - 1];
		i--;
	}
	ps->a[pos] = x;
	ps->size++;
	return;
}

将pos位置往后的数字向后挪一位，给pos腾出位置

顺序表的删除 

void SLerase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	int i = pos;
	while (i < ps->size - 1)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
	return;
}

顺序表的查找        

int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
			return i;
	}
	return -1;//没找到就 返回-1
}

 顺序表的修改

void SLChange(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	ps->a[pos] = x;
	return;
}