⚡线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使
用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，
线性表在物理上存储时，通常以数组和链式结构的形式存储。

---

⚡顺序表

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存
储。在数组上完成数据的增删查改。

顺序表一般可以分为：

• 静态顺序表：使用定长数组存储元素。

#define MAX 10
typedef int SLDatatype;
typedef struct SeqList
{
	SLDatatype a[MAX];     //定长数组
    int size;              //有效数据个数
}SL;

• 动态顺序表：使用动态开辟的数组存储。

typedef int SLDatatype;
typedef struct SeqList
{
	SLDatatype* a;         //动态开辟数组的
	int size;              //存储的有效数据的个数
	int capacity;          //容量
}SL;

---

⚡顺序表各接口实现

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

//动态顺序表
typedef int SLDatatype;
typedef struct SeqList
{
	SLDatatype* a;         //指向动态开辟的数组
	int size;              //存储的有效数据的个数
	int capacity;          //容量
}SL;

顺序表初始化：

void SLInit(SL* psl)
{
	assert(psl);
	psl->a = (SLDatatype*)malloc(sizeof(SLDatatype)*4);
	if (psl->a == NULL)
	{
		printf("malloc\n");
		return;
	}
	psl->size = 0;
	psl->capacity = 4;
}

判断是否需要进行增容：

void SLCheckCapacity(SL* psl)
{
	assert(psl);
	if (psl->size == psl->size)
	{
		SLDatatype* tmp = (SLDatatype*)realloc(psl->a, sizeof(SLDatatype) * psl->capacity * 2);
		psl->capacity += 2;
		if (tmp == NULL)
	    {
			printf("realloc\n");
			return;
	    }
		psl->a = tmp;
		psl->capacity *= 2;
	}

顺序表尾插：

void SLPushBack(SL* psl, SLDatatype x)
{
	assert(psl);
	SLCheckCapacity(psl);
	psl->a[psl->size++] = x;
}

顺序表尾删：

void SLPopBack(SL* psl)
{
	assert(psl);
	//暴力检查
	assert(psl->size > 0);
	温柔检查
	//if (psl->size == 0);
	//{
	//	return;
	//}
	psl->size--;
}

顺序表头插：

void SLPushFront(SL* psl, SLDatatype x)
{
	assert(psl);
	SLCheckCapacity(psl);
	int end = psl->size - 1;
	while (end >= 0)
	{
		psl->a[end + 1] = psl->a[end];
		end--;
	}
	psl->a[0] = x;
	psl->size++;
}

顺序表头删：

void SLPopFront(SL* psl)
{
	assert(psl);
	//暴力检查
	assert(psl->size > 0);
	int start = 0;
	while (start < psl->size - 1)
	{
		psl->a[start] = psl->a[start+1];
		start++;
	}
	psl->size--;
}

顺序表查找：

int SLFind(SL* psl, SLDatatype x)
{
	assert(psl);
	for (int i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

顺序表在pos位置插入x：

void SLInsert(SL* psl, int pos, SLDatatype x)
{
	assert(psl);
	assert(pos >= 0 && pos <= psl->size);
	SLCheckCapacity(psl);
	int end = psl->size - 1;
	while (end >= pos)
	{
		psl->a[end + 1] = psl->a[end];
		end--;
	}
	psl->a[pos] = x;
	psl->size++;
}

 顺序表修改pos位置的值：

void SLModify(SL* psl, int pos, SLDatatype x)
{
	assert(psl);
	assert(pos > 0 && pos < psl->size);
	psl->a[pos] = x;
}

顺序表删除pos位置的值：

void SLErase(SL* psl, int pos)
{
	assert(psl);
	assert(pos >= 0 && pos < psl->size);
	assert(psl->size > 0);
	int start = pos + 1;
	while (start < psl->size)
	{
		psl->a[start - 1] = psl->a[start];
		start++;
	}
	psl->size--;
}

顺序表销毁：

void SLDestroy(SL* psl)
{
	assert(psl);
	free(psl->a);
	psl->a = NULL;
}

顺序表打印：

void SLPrint(SL* psl)
{
	assert(psl);
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

---

感谢大家能够看完这篇博客，创作时长，小伙伴们觉得我的博客对你有帮助，不妨留下你的点赞的收藏，关注我，带你了解不一样的数据结构。