数据结构入门——02顺序表

1.线性表

线性表：在内存可以不连续，但逻辑上是连续的，通常以数组和链式结构的形式存储。线性表是一种在实际中广泛使用的数据结构。

常见的线性表：顺序表、链表、栈、队列、字符串...

线性表的特征：

1. 对非空表,a0是表头,无前驱；
2. an-1是表尾,无后继；
3. 其它的每个元素ai有且仅有一个直接前驱ai-1和一个直接后继ai+1。

2.顺序表

顺序表在逻辑上相连，物理相连，存储密度很高，一般情况下采用数组存储。在数组上完成数据的增删该查。适合在查找多，存储删除少的情景使用。

存储密度=(数据结构中元素所占存储空间)/（整个数据结构所占空间）

• 顺序表的优点：随机访问快，内存利用率高，有序性强，简单易用。
• 顺序表的缺点： 对表的插入和删除等运算的时间复杂度较差。在运算过程中，存在元素在存储器中成片移动现象。

顺序表可以分为：

1. 静态顺序表：使用定长数组存储。
2. 动态顺序表：使用动态开辟的数组存储

// 顺序表的静态存储
#define N 100
typedef int SLDataType;

typedef struct SeqList
{
    SLDataType array[N]; // 定长数组
    size_t size; // 有效数据的个数
}SeqList;


// 顺序表的动态存储
typedef struct SeqList
{
    SLDataType* array; // 指向动态开辟的数组
    size_t size ; // 有效数据个数
    size_t capicity ; // 容量空间的大小
}SeqList;

3.动态顺序表的实现

typedef struct SeqList
{
    SLDataType* array; // 指向动态开辟的数组
    size_t size ; // 有效数据个数
    size_t capicity ; // 容量空间的大小
}SeqList;

 3.1顺序表初始化

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

	psl->a = NULL;
	psl->size = 0;
	psl->capacity = 0;
}

 3.2顺序表销毁

// 顺序表销毁
void SeqListDestroy(SeqList* psl)
{
	assert(psl);
	free(psl->a);
	psl->a = NULL;
	psl->capacity = psl->size = 0;
}

3.3顺序表打印

// 顺序表打印
void SeqListPrint(SeqList* psl)
{
	assert(psl);

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

3.4检查空间，如果满了，进行增容

// 检查空间，如果满了，进行增容
void SeqListCheckCapacity(SeqList* psl)
{
	assert(psl);

	// 如果满了，我们要扩容
	if (psl->size == psl->capacity)
	{
		size_t newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;
		SLDataType* tmp = realloc(psl->a, sizeof(SLDataType)*newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			psl->a = tmp;
			psl->capacity = newCapacity;
		}
	}
}

3.5顺序表尾插

// 顺序表尾插
void SeqListPushBack(SeqList* psl, SLDataType x)
{
	assert(psl);

	/*SeqListCheckCapacity(psl);

	psl->a[psl->size] = x;
	psl->size++;*/

	SeqListInsert(psl, psl->size, x);
}

3.6顺序表尾删

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

	//psl->a[psl->size - 1] = 0;
	/*if (psl->size > 0)
	{
		psl->size--;
	}*/
	SeqListErase(psl, psl->size-1);
}

3.7顺序表头插

// 顺序表头插
void SeqListPushFront(SeqList* psl, SLDataType x)
{
	assert(psl);

	//SeqListCheckCapacity(psl);

	 挪动数据，腾出头部空间
	//int end = psl->size - 1;
	//while (end >= 0)
	//{
	//	psl->a[end + 1] = psl->a[end];
	//	--end;
	//}

	//psl->a[0] = x;
	//psl->size++;

	SeqListInsert(psl, 0, x);
}

3.8顺序表头删

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

	// 挪动数据覆盖删除
	/*if (psl->size > 0)
	{
		int begin = 1;
		while (begin < psl->size)
		{
			psl->a[begin - 1] = psl->a[begin];
			++begin;
		}

		--psl->size;
	}*/
	SeqListErase(psl, 0);
}

3.9顺序表查找

// 顺序表查找
int SeqListFind(SeqList* psl, SLDataType x)
{
	assert(psl);

	for (int i = 0; i < psl->size; ++i)
	{
		if (psl->a[i] == x)
		{
			return i;
		}
	}

	return -1;
}

3.10顺序表在pos位置插入x

// 顺序表在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
{
	// 暴力检查
	assert(psl);

	// 温和检查
	if (pos > psl->size)
	{
		printf("pos 越界：%d\n", pos);
		return;
		//exit(-1);
	}
	// 暴力检查
	//assert(pos <= psl->size);

	SeqListCheckCapacity(psl);

	//int end = psl->size - 1;
	//while (end >= (int)pos)
	//{
	//	psl->a[end + 1] = psl->a[end];
	//	--end;
	//}

	size_t end = psl->size;
	while (end > pos)
	{
		psl->a[end] = psl->a[end-1];
		--end;
	}

	psl->a[pos] = x;
	psl->size++;
}

3.11顺序表删除pos位置的值

// 顺序表删除pos位置的值
void SeqListErase(SeqList* psl, size_t pos)
{
	assert(psl);
	assert(pos < psl->size);

	size_t begin = pos + 1;
	while (begin < psl->size)
	{
		psl->a[begin - 1] = psl->a[begin];
		++begin;
	}

	psl->size--;
}