【数据结构】静态顺序表各种功能实现(C语言)

最新推荐文章于 2024-04-16 20:35:12 发布

圈圈圆圆圈圈_

最新推荐文章于 2024-04-16 20:35:12 发布

阅读量1.2k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： C语言

本文链接：https://blog.youkuaiyun.com/baidu_41813368/article/details/82770433

C语言专栏收录该内容

28 篇文章

订阅专栏

本文详细介绍了一种基于数组实现的顺序表数据结构，并提供了初始化、销毁、打印等基本操作的实现方法，还深入探讨了如何进行元素的插入、删除、查找等高级功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

顺序表的存储方式

在这里插入图片描述

定义一个顺序表

#define MAX_SIZE (100)
 typedef int DataType; 
 typedef struct SeqList 
 { 
 	DataType data[MAX_SIZE]; 
 	int size; 
 }	SeqListR;

顺序表要实现的功能

 void InitSeqList(SeqListR *pSeq);
 //初始化顺序表

 void DestroySeqList(SeqListR *pSeq);
 //销毁顺序表

 void PrintSeqList(const SeqListR *pSeq);
 //打印顺序表的内容

 void PushBack(SeqListR *pSeq, DataType data);
 //在顺序表的尾部插入一个值为data的元素

 void PushFront(SeqListR *pSeq, DataType data);
 //在顺序表的头部插入一个值为data的元素

 void Insert(SeqListR *pSeq, int pos, DataType d);
 //在顺序表的pos位置处插入一个值为data的元素

 void PopBack(SeqListR *pSeq);
 //在顺序表的尾部删除一个元素
 
 void PopFront(SeqListR *pSeq);
 //在顺序表的头部删除一个元素

 void Erase(SeqListR *pSeq,int pos);
 //在pos位置处删除一个元素

 void Sort(SeqListR *pSeq);
 //冒泡排序

 void SelectSearch(SeqListR *pSeq);
 //选择排序

 int BinarySearch(SeqListR *pSeq, DataType data);
 //二分查找

 int Find( const SeqListR *pSeq, DataType data);
 //在一个无序顺序表中查找一个data的元素,找到返回所在的位置,找不到返回-1

 void Remove(SeqListR *pSeq, DataType data);
 //删除顺序表中第一次遇到data

 void RemoveAll(SeqListR *pSeq,DataType data);
 //删除顺序表中所有的data

各项功能的具体实现

初始化顺序表

void InitSeqList(SeqListR *pSeq) //初始化顺序表
{
	assert(pSeq != NULL);
	int i = 0;
	pSeq->size = 0;
}

销毁顺序表

void DestroySeqList(SeqListR *pSeq)//销毁顺序表
{
	assert(pSeq != NULL);
	pSeq->size = 0;
}

打印顺序表

void PrintSeqList(const SeqListR *pSeq)//打印顺序表
{
	for (int i = 0; i < pSeq->size; i++)
	{
		printf(" %d ", pSeq->data[i]);
	}
	printf("\n");
}

尾插

void PushBack(SeqListR *pSeq, DataType data)//尾插
{
	if (pSeq->size == MAX_SIZE)
	{
		printf("满了\n");
		return;
	}
	pSeq->data[pSeq->size] = data;//在size所指的位置插入数字
	pSeq->size += 1;
}

头插

void PushFront(SeqListR *pSeq, DataType data)//头插
{
	if (pSeq->size == MAX_SIZE)
	{
		printf("满了\n");
		return;
	}
	for (int i = pSeq->size - 1; i >= 0; i--)//i的含义是数据的下标
	{
		pSeq->data[i+1] = pSeq->data[i];
	}
	for (int j = pSeq->size; j > 0; j--)//j的含义是空间的下标
	{
		pSeq->data[j] = pSeq->data[j-1];
	}
	pSeq->data[0] = data;
	pSeq->size++;
}

指定位置的插入

void Insert(SeqListR *pSeq, int pos, DataType data)//指定位置的插入
{
	assert(pSeq->size < MAX_SIZE);
	assert(pos >= 0 && pos <= pSeq->size);
	for (int i = pSeq->size ; i >= pos + 1; i--)//i的含义是数据的下标
	{
		pSeq->data[i] = pSeq->data[i-1];
	}
	pSeq->data[pos] = data;
	pSeq->size+=1;
}

尾删

void PopBack(SeqListR *pSeq)//尾删
{
	assert(pSeq != NULL);//传入地址不为空
	assert(pSeq->size > 0);//顺序表不为空
	pSeq->size--;
}

头删

void PopFront(SeqListR *pSeq)//头删
{
	assert(pSeq != NULL);
	assert(pSeq->size > 0);
	for (int i = 1; i <= pSeq->size-1; i++)//i的含义是数据的下标
	{
		pSeq->data[ i ] = pSeq->data[i+1];
	}
	//for (int j = 0; j <= pSeq->size - 2; j++)//j的含义是空间的下标
	//{
	//	pSeq->data[j] = pSeq->data[j + 1];
	//}
	//pSeq->size--;
}

指定位置的删除

void Erase(SeqListR *pSeq, int pos)//指定位置的删除
{
	assert(pSeq != NULL);//传入地址不为空
	assert(pSeq->size > 0);//顺序表不为空
	assert(pos >= 0 && pos < pSeq->size);//删除的数的位置不能超过size的大小
	for (int i = pos; i <= pSeq->size - 2; i++)
	{
		pSeq->data[i] = pSeq->data[i + 1];
	}
	pSeq->size--;
}

查找无序顺序表

int Find(SeqListR *pSeq, DataType data)//查找无序顺序表
{
	for (int i = 0; i < pSeq ->size; i++)
	{
		if (data == pSeq->data[i])
		{
			return i;
		}
	}
	return -1;
}

删除遇到的第一个数字

void Remove(SeqListR *pSeq, DataType data)//删除第一个遇到的数字
{
	int pos = Find(pSeq, data);
	if (pos == -1);
	{
		return -1;
	}
	Erase(pSeq, pos);
	//for (int i = 0; i <= pSeq->size; i++)
	//{
	//	if (data == pSeq->data[i])
	//	{
	//		for (int j = i; j <= pSeq->size - 2; j++)
	//		{
	//			pSeq->data[j] = pSeq->data[j + 1];
	//		}
	//		pSeq->size--;
	//	}
	//}
}

删除查找到的所有data

void RemoveAll(SeqListR *pSeq, DataType data)//删除查找到的所有data
{
	while (Remove(pSeq, data) != -1)
	{
	}
	//时间复杂度O(n^2)
	
	int i = 0;
	int j = 0;
	//新建数组,把不等于 data 的数据 copy 到 extra
	DataType *extra = (DataType *)malloc(sizeof(DataType)*pSeq->size);
	for (; i < pSeq->size; i++)
	{
		if (pSeq->data[i] != data)
		{
			extra[j++] = pSeq->data[i];
		}
	}
	//从extra拷贝回原来的顺序表
	for (int k = 0; k < j; k++)
	{
		pSeq->data[k] = extra[k];
	}
	pSeq->size = j;//j刚好就是剩下的数据个数
	free(extra);
	//空间复杂度O(n)

	int i = 0, j = 0;
	for (; i < pSeq->size; i++)
	{
		if (pSeq->data[i] != data)
		{
			pSeq->data[j++] = pSeq->data[i];
		}
	}
	pSeq->size = j;
	//空间复杂度O(1)
}

void Swap(DataType *a, DataType *b)
{
	DataType t = *a;
	*a = *b;
	*b = t;
}

方法一：创建额外的空间
在这里插入图片描述
方法二：

冒泡排序

void Sort(SeqListR *pSeq)//冒泡排序
{
	int i = 0, j = 0;
	bool sorted = true;
	for (i = 0; i < pSeq->size; i++)
	{
		sorted = true;
		for (j = 0; j < pSeq->size - i; j++)
		{
			if (pSeq->data[j] > pSeq->data[j + 1])
			{
				Swap(pSeq->data[j], pSeq->data[j + 1]);
				sorted = false;
			}
		}
		 //一次冒泡过程中，一次交换都没有，所以已经有序了
		if (sorted)
		{
			break;
		}
	}
}

二分查找

int BinarySearch(SeqListR *pSeq, DataType data)//二分查找
{
	int left = 0;
	int right = pSeq->size;
	while (left < right)
	{
		int mid = left + ( right - left ) / 2;
		if (pSeq->data[mid] == data)
		{
			return mid;
		}
		else if (pSeq->data[mid] > data)
		{
			right = mid;
		}
		else if (pSeq->data[mid] < data)
		{
			left = mid;
		}
		else
		{
			return -1;
		}
	}	
}

选择排序

void SelectSearch(SeqListR *pSeq)//选择排序
{
	int minSpace = 0;
	int maxSpace = pSeq->size-1;
	while (minSpace<maxSpace)//区间内只剩一个数或零个数
	{
		int minPos = minSpace;//假设第一个就是最小的
		int maxPos = minSpace;//假设第一个就是最大的
		for (int j = minSpace; j <= maxSpace; j++)
		{ 
			if (pSeq->data[j] < pSeq->data[minPos])
			{
				minPos = j;//找到最小的数存在的位置
			}
			if (pSeq->data[j] > pSeq->data[maxPos])
			{
				maxPos = j;//找到最大的数存在的位置
			}
		}

		Swap(pSeq->data + minSpace, pSeq->data + minPos);//找到最小的数放在最小的位置
		 // 最大的数就是区间内的第一个的时候
		if (minSpace == maxPos) 
		{
			maxPos = minPos;
		}
		Swap(pSeq->data + maxSpace, pSeq->data + maxPos);

		minSpace++;
		maxSpace--;
		}
}

在这里插入图片描述