1.

顺序表（Sequence List）是一种线性表的实现方式，通过连续的内存空间存储元素，按照顺序排列。

顺序表的特点包括：

• 元素在内存中的存储是连续的，通过数组实现。
• 元素之间的逻辑顺序与物理顺序一致。
• 可以根据元素的索引直接访问和修改元素。
• 需要预先分配足够的内存空间，容量固定。

顺序表常见的操作包括：

• 创建：通过动态内存分配，创建一个具有指定容量的顺序表。
• 销毁：释放顺序表占用的内存空间。
• 清空：将顺序表中的元素清空，使其为空表。
• 插入：在指定位置插入一个元素，后面的元素依次后移。
• 删除：删除指定位置的元素，后面的元素依次前移。
• 访问：根据索引访问指定位置的元素。
• 查询：根据元素的值查找元素在顺序表中的位置。
• 修改：根据索引修改指定位置的元素的值。
• 排序：对顺序表中的元素进行排序，常用的算法有冒泡排序、插入排序、快速排序等。
• 遍历：按照顺序依次访问顺序表中的元素。

优点：

随机访问效率高，可以直接通过索引定位元素，不需要遍历，不容易产生内存碎片

缺点：

插入和删除操作需要移动大量元素，效率较低，并且容量固定，无法动态扩容。

另外注意的是，在使用顺序表时，需要进行边界检查，避免越界访问。此外，插入和删除元素时需要注意维护顺序表的逻辑和物理顺序一致性。

代码实现

设计顺序表结构

//	设计顺序表结构
typedef struct Array
{
	TYPE* ptr;		//	存储元素的内存首地址
	size_t cal;		//	表的容量
	size_t cnt;		//	元素的数量
}Array;

创建

//	创建
Array* create_array(size_t cal)
{
	Array* arr = malloc(sizeof(Array));   //	给顺序表结构分配内存 

	arr->ptr = malloc(sizeof(TYPE)*cal);    //	给数据元素分配内存
	
	arr->cal = cal;        //	给数据元素分配内存

	arr->cnt = 0;        //	初始化元素的数量

	return arr;
}

销毁

//	销毁
void destroy_array(Array* arr)
{
	free(arr->ptr);
	free(arr);
}

清空

//	销毁
void destroy_array(Array* arr)
{
	free(arr->ptr);
	free(arr);
}

插入

//	插入
bool insert_array(Array* arr,size_t index,TYPE data)
{
	//	判断表是否满
	if(arr->cnt >= arr->cal)	return false;
	//	判断下标是否能保持元素的连续性
	if(index > arr->cnt) return false;


	//	数据向后移动
	for(int i=arr->cnt; i>index; i--)
	{
		arr->ptr[i] = arr->ptr[i-1];	
	}

	//	插入数据
	arr->ptr[index] = data;
	arr->cnt++;
	return true;
}

删除

//	删除
bool delete_array(Array* arr,size_t index)
{
	if(index >= arr->cnt) return false;   //判断表是否满
	
	for(int i=index; i<arr->cnt-1; i++)
	{
		arr->ptr[i] = arr->ptr[i+1];
	}
	
	arr->cnt--;
	return true;
}

访问

//	访问
bool access_array(Array* arr,size_t index,TYPE* data)
{
	if(index >= arr->cnt) return false;
	*data = arr->ptr[index];
	return true;
}

查询

//	查询
int query_array(Array* arr,TYPE data)
{
	for(int i=0; i<arr->cnt; i++)
		if(arr->ptr[i] == data) return i;
	return -1;
}

修改

//	修改
bool modify_array(Array* arr,size_t index,TYPE data)
{
	if(index >= arr->cnt) return false;
	arr->ptr[index] = data;
	return true;
}

排序

//	排序
void sort_array(Array* arr)
{
	for(int i=0; i<arr->cnt-1; i++)
	{
		for(int j=i+1; j<arr->cnt; j++)	
		{
			if(arr->ptr[j] < arr->ptr[i])
			{
				TYPE temp = arr->ptr[j];
				arr->ptr[j] = arr->ptr[i];
				arr->ptr[i] = temp;
			}
		}
	}
}

遍历

//	遍历
void show_array(Array* arr)
{
	for(int i=0; i<arr->cnt; i++)
	{
		printf(PH,arr->ptr[i]);	
	}
	printf("\n");
}

完整代码

1. #include <stdio.h>
   #include <stdbool.h>
   #include <stdlib.h>
   #include <string.h>
   
   #define TYPE int
   #define PH "%d "
   
   //	设计顺序表结构
   typedef struct Array
   {
   	TYPE* ptr;		//	存储元素的内存首地址
   	size_t cal;		//	表的容量
   	size_t cnt;		//	元素的数量
   }Array;
   
   //	创建
   Array* create_array(size_t cal)
   {
   	//	给顺序表结构分配内存
   	Array* arr = malloc(sizeof(Array));
   	//	给数据元素分配内存
   	arr->ptr = malloc(sizeof(TYPE)*cal);
   	//	记录表的容量
   	arr->cal = cal;
   	//	初始化元素的数量
   	arr->cnt = 0;
   
   	return arr;
   }
   
   //	销毁
   void destroy_array(Array* arr)
   {
   	free(arr->ptr);
   	free(arr);
   }
   //	清空
   void clear_array(Array* arr)
   {
   	arr->cnt = 0;	
   }
   
   //	插入
   bool insert_array(Array* arr,size_t index,TYPE data)
   {
   	//	判断表是否满
   	if(arr->cnt >= arr->cal)	return false;
   	//	判断下标是否能保持元素的连续性
   	if(index > arr->cnt) return false;
   
   	//	数据向后移动
   	for(int i=arr->cnt; i>index; i--)
   	{
   		arr->ptr[i] = arr->ptr[i-1];	
   	}
   
   
   	//	插入数据
   	arr->ptr[index] = data;
   	arr->cnt++;
   	return true;
   }
   
   //	删除
   bool delete_array(Array* arr,size_t index)
   {
   	if(index >= arr->cnt) return false;
   	
   	for(int i=index; i<arr->cnt-1; i++)
   	{
   		arr->ptr[i] = arr->ptr[i+1];
   	}
   	
   	arr->cnt--;
   	return true;
   }
   
   //	访问
   bool access_array(Array* arr,size_t index,TYPE* data)
   {
   	if(index >= arr->cnt) return false;
   	*data = arr->ptr[index];
   	return true;
   }
   
   //	查询
   int query_array(Array* arr,TYPE data)
   {
   	for(int i=0; i<arr->cnt; i++)
   		if(arr->ptr[i] == data) return i;
   	return -1;
   }
   //	修改
   bool modify_array(Array* arr,size_t index,TYPE data)
   {
   	if(index >= arr->cnt) return false;
   	arr->ptr[index] = data;
   	return true;
   }
   
   //	排序
   void sort_array(Array* arr)
   {
   	for(int i=0; i<arr->cnt-1; i++)
   	{
   		for(int j=i+1; j<arr->cnt; j++)	
   		{
   			if(arr->ptr[j] < arr->ptr[i])
   			{
   				TYPE temp = arr->ptr[j];
   				arr->ptr[j] = arr->ptr[i];
   				arr->ptr[i] = temp;
   			}
   		}
   	}
   }
   
   //	遍历
   void show_array(Array* arr)
   {
   	for(int i=0; i<arr->cnt; i++)
   	{
   		printf(PH,arr->ptr[i]);	
   	}
   	printf("\n");
   }
   
   int main(int argc,const char* argv[])
   {
   	Array* arr = create_array(10);	
   
   	for(int i=0; i<5; i++)
   	{
   		insert_array(arr,0,i+1);	
   	}
   
   	insert_array(arr,1,8);	
   	delete_array(arr,5);
   	show_array(arr);
   
   	int num = 0;
   	if(access_array(arr,5,&num))
   		printf("num=%d\n",num);
   	else
   		printf("index error\n");
   	
   	printf("index=%d\n",query_array(arr,80));
   
   	sort_array(arr);
   	clear_array(arr);
   	show_array(arr);
   	destroy_array(arr);
   
   }