【数据结构】线性结构

【数据结构】线性结构–>顺序表

前言：

线性表是最常用且最简单的一种数据结构；简言之，一个线性表是n个数据元素的有限序列。线性表在逻辑上是线性结构，但在物理结构上不一定是连续的，线性表在物理存储时，通常以数组和链式结构的形式存储。本章涉及到的是顺序表和链表。

一、顺序表

1.1概念与结构

概念：顺序表是用一段物理地址连续存储的存储单元依次存储数据元素的线性结构，一般情况采用数组存储。

顺序表的底层结构是数组，对数组的封装实现了常用的增删改查等接口。线性表的顺序存储结构是一种随机存取的存储结构。

1.2 顺序表的特点：

• 随机访问：通过首地址和元素序号在常数时间内找到指定的元素。
• 内存使用效率高：在创建顺序表时需预先分配一定的内存空间；在元素数量较多的且连续存储的情况下，空间利用率相对较高。
• **操作特性1：**在线性表的顺序存储结构中，由于逻辑上相邻的数据元素在物理位置上也是相邻的，所以在插入删除操作中，需要大量移动元素。
• 操作特性2：当在顺序存储结构的线性表中某个位置上插入或删除一个数据元素时，其时间主要耗费在移动元素上（换句话说，移动元素的操作作为预估算法时间复杂度的基本操作），而移动元素的个数取决于插入或删除元素的位置。

1.2.1 顺序表描述：

顺序表分为静态和动态，由于静态顺序表是事先开辟好空间的，灵活性较低，若空间给的多了会造成浪费，若少了则不够用；而动态顺序表则是按需申请，这里重点讲动态顺序表。

静态顺序表存储结构：

动态顺序表存储结构：

1.3动态顺序表的实现：

顺序表的基本操作有：初始化和销毁、头部插入删除/尾部插入删除、在指定位置之前插入数据/删除数据。

实现前的准备工作：头文件SeqList.h

typedef int SLDataType;
// 动态顺序表 -- 按需申请
typedef struct SeqList
{
 SLDataType* a;
 int size; // 有效数据个数
 int capacity; // 空间容量
}SL;
//初始化和销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPrint(SL* ps);
//检查空间是否足够，不够就扩容
void SLCheckCapacity(SL* ps);
//头部插⼊删除 / 尾部插⼊删除
void SLPushBack(SL* ps, SLDataType x);
void SLPopBack(SL* ps);
void SLPushFront(SL* ps, SLDataType x);
void SLPopFront(SL* ps);
//指定位置之前插⼊/删除数据
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);
int SLFind(SL* ps, SLDataType x);

1.3.1 初始化：

//初始化
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

1.3.2 销毁：

//销毁
void SLDestroy(SL* ps)
{
	if (ps->arr)//相当于ps->arr != NULL
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

1.3.3 检查空间是否足够（realloc）

void SLCheckCapacity(SL* ps)
{
	//判断空间是否充足
	if (ps->size == ps->capacity)
	{
		//增容//0*2 = 0
		//若capacity为0，给个默认值，否则×2倍
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDatatype* tmp = (SLDatatype*)realloc(ps->arr, newCapacity * sizeof(SLDatatype));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}

1.3.4 头部插⼊删除 / 尾部插⼊删除

void SLPushBack(SL* ps, SLDatatype x)
{
	//粗暴的解决方法---断言
	assert(ps);//等价于assert(ps != NULL)

	温柔的解决方式
	//if (ps == NULL)
	//{
	//	return;
	//}
	SLCheckCapacity(ps);
	ps->arr[ps->size++] = x;
}
void SLPushFront(SL* ps, SLDatatype x)
{
	assert(ps);
	//判断空间是否足够
	SLCheckCapacity(ps);

	//数据整体后移一位
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	//下标为0的位置空出来
	ps->arr[0] = x;

	ps->size++;
}

//输出
void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

//删除
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);

	//ps->arr[ps->size - 1] = -1;//多余了
	ps->size--;
}
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size);

	//数据整体向前挪动一位
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];//i = size-2
	}
	ps->size--;
}

1.3.5 指定位置之前插⼊/删除数据

//在指定位置之前插入数据(空间足够才能直接插入数据）
void SLInsert(SL* ps, SLDatatype x, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);

	SLCheckCapacity(ps);

	//pos及之后的数据整体向后移动一位
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1]; //pos+1   ->   pos
	}

	ps->arr[pos] = x;
	ps->size++;
}

//删除指定位置的数据
void SLErase(SL* ps, int pos)
{
	assert(ps);

	for (int i = pos; i < ps->size; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}