【数据结构】1.顺序表-CSDN博客

本文链接：https://blog.csdn.net/qq_44828389/article/details/105490888

顺序表

1.顺序表的概念及结构

顺序表一般可分为：

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;

2.特点

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多

了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下

面实现动态顺序表。

3.动态顺序表的实现

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

// 基本增删查改接口

// 顺序表初始化
void SeqListInit(SeqList* psl, size_t capacity);

// 顺序表销毁
void SeqListDestory(SeqList* psl);

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

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

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

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

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

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

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

// 顺序表在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);

// 顺序表删除pos位置的值
void SeqListErase(SeqList* psl, size_t pos);

3.1 顺序表初始化

**void SeqListInit(SeqList* ps);**

void SeqListInit(SeqList* ps)//初始化
{

	assert(ps);
	ps->_a = NULL;
	ps->_size = 0;
	ps->_capacity = 0;
}

3.2 顺序表销毁

**void SeqListDestory(SeqList* ps);**

void SeqListDestory(SeqList* ps)//销毁空间
{
	free(ps->_a);
	ps->_a = NULL;
	ps->_size = 0;
	ps->_capacity = 0;
}

3.3 顺序表打印

**void SeqListPrint(SeqList* ps);**

void SeqListPrint(SeqList* ps)//打印
{
	assert(ps);
	for (size_t i = 0; i < ps->_size; ++i)
	{
		printf("%d ", ps->_a[i]);
	}
	printf("\n");
}

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

**void CheckCapacity(SeqList* ps);**

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

	if (ps->_size == ps->_capacity)
	{
		size_t newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		                                // == 0 赋值4 不等于0 执行后面的*2
		ps->_a = realloc(ps->_a, newcapacity * sizeof(SLDataType));
		//realloc（要调整的内存地址，调整后的大小——要字节数）空间扩容
		ps->_capacity = newcapacity;
	}

}

3.5 顺序表尾插

**void SeqListPushBack(SeqList* ps, SLDataType x);**

void SeqListPushBack(SeqList* ps, SLDataType x) //尾插
{
	assert(ps);
	SeqListCheckCapacity(ps);
	ps->_a[ps->_size] = x;//size代表数组下标表示的是最后一个位置的下一个位置
	ps->_size++;			

}

3.6 顺序表尾删

**void SeqListPopBack(SeqList* ps);**

void SeqListPopBack(SeqList* ps)  //尾删
{
	assert(ps && ps->_size > 0);
	//ps->_a[ps->_size - 1] = 0;//数据的个数比数组下标数值多一
	ps->_size--;

}

3.7 顺序表头插

**void SeqListPushFront(SeqList* ps, SLDataType x);**

void SeqListPushFront(SeqList* ps, SLDataType x) //头插
{
	assert(ps);
	SeqListCheckCapacity(ps);//空间扩容
	//挪动数据  从后往前挪
	int end = ps->_size - 1; //这里为什么定义size-1呢 因为end代表数组下标 并非元素个数
	for ( ; end >= 0; --end)
	{
		ps->_a[end + 1] = ps->_a[end];  //前面的给后面的赋值 一次往后移动
	}
	ps->_a[0] = x;
	ps->_size++;//插入一个数据的同时要增加size个数


}

3.8 顺序表头删

**void SeqListPopFront(SeqList* ps);**

void SeqListPopFront(SeqList* ps)  //头删
{
	assert(ps && ps->_size > 0);

	for (size_t start = 0; start <= ps->_size - 1; ++start)
	{
		ps->_a[start] = ps->_a[start + 1];
	}

	ps->_size--;
}

3.9 顺序表查找

**int SeqListFind(SeqList* ps, SLDataType x);**

int  SeqListFind(SeqList*ps, SLDataType x)//查找
{
	assert(ps);
	for (size_t i = 0; i <= ps->_size-1; ++i)
	{
		if (ps->_a[i] == x)
		{
			return i;
		}

	}
	return -1;

}

3.10 顺序表在pos位置插入x

**void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);**

void SeqListInsert(SeqList*ps, size_t pos, SLDataType x)//插入 其中pos表示插入的位置
{
	assert(ps && pos < ps->_size);
	SeqListCheckCapacity(ps);
	int  end = ps->_size ;  

	while (end >= (int)pos)//防止隐式类型转换
	{
		ps->_a[end] = ps->_a[end - 1];
		--end;
	}
	ps->_a[pos] = x;
	ps->_size++;
}

3.11 顺序表删除pos位置的值

**void SeqListErase(SeqList* psl, size_t pos);**

void SeqListErase(SeqList*ps, size_t pos)//删除

{
	assert(ps && pos < ps->_size);
	size_t i = pos + 1;
	while (i <= ps->_size - 1)
	{
		ps->_a[i - 1] = ps->_a[i];
		++i;
	}

	ps->_size--;


}

3.11 冒泡排序

**void SeqListBubbleSoet(SeqList* ps)**

void SeqListBubbleSoet(SeqList* ps)//冒泡排序
{
	 //控制冒泡的终止位置
	 for (size_t end = ps->_size; end > 0; --end)
	 {
		 int exchange = 0;
		 //单趟冒泡
		 for (size_t i = 0; i < end - 1; i++)//注意起始位置与终止位置
		 {
			 if (ps->_a[i] > ps->_a[i + 1])
			 {
				 SLDataType tmp = ps->_a[i];
				 ps->_a[i] = ps->_a[i + 1];
				 ps->_a[i + 1] = tmp;

				 exchange = 1;
			 }
		 }
		 if (exchange == 0)
		 {
			 break;
		 }
	 }
}

3.12 二分查找

**int SeqListBinaryFind(SeqList* ps, SLDataType x)**

int  SeqListBinaryFind(SeqList* ps, SLDataType x) //二分查找
 {
	 size_t begin = 0, end = ps->_size-1;
	 while (begin <= end )
	 {
		 size_t mid = (begin + end) / 2;
		 if (ps->_a[mid] == x)
		 {
			 return mid;
		 }
		 else if (ps->_a[mid] < x)
		 {
			 begin = mid + 1;
		 }
		 else
		 {
			 end = mid - 1;
		 }
	 }
	 return -1;