动态顺序表

最新推荐文章于 2023-07-26 19:50:28 发布

melody_jae

最新推荐文章于 2023-07-26 19:50:28 发布

阅读量390

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/melody_1016/article/details/83902064

版权

数据结构专栏收录该内容

8 篇文章 0 订阅

订阅专栏

我们对静态顺序表可能比较熟悉，它的定义方式是

struct SeqList
{
   int arr[100];
   int _size;//当前存放数据的个数
};

主要思想就是利用数组可以一次性开辟一整块空间，存放我们想要的数据。从这个结构体的定义，我们可以获得如下信息：

开辟的空间大小为100，（即可以存放100个整型数据），_size记录了当前数组中有效元素的个数，为什么要有这一项呢？这就和我们的操作有关，基本的操作肯定是增删查改数据。举个例子，“增”，我们已经知道了数组的大小是100，当不断往数组中存放数据时，肯定要进行计数吧，得知道自己已经存放了多少数据；如果个数已经达到100，那说明满了，不可能再存入了。这里的_size就是这个作用。

数据要放到内存中，总结一下，就是存数据时，必须：

（1）有空间

（2）得知道空间大小

（3）不可能随意存取，因为开辟的空间肯定存在“满”和“空”的情况，所以还需要一个变量时刻记录当前空间的情况（即_size）

静态顺序表的弊端想必大家也知道：大小是固定的,存取时灵活性不高，很容易出现空间浪费和空间太小的情况。

接下来我们再看动态顺序表，首先看它的定义：

typedef struct SeqList
{
	DataType*_pData;
	int _capacity;//容量
	int _size;//有效元素的个数

}SeqList;

好了，凡事首先反问自己为什么？为什么要这么定义？为什么这个结构体内要有这三个变量？既然是动态开辟空间存放数据，直接在main函数中定义一个int*p=（int*）malloc(sizeof(int)*size)，（即开辟已经大小的空间）然后写几个函数增删查改不就可以了吗？为啥还要搞一个结构体看着那么麻烦。

先不揭晓答案，就按我们想得做，不定义任何结构体，我们想“存取”数据。

#include<stdio.h>
#include<stdlib.h>
int _sz=0;
void PushBack(int*a, int data,int size)
{
	//static int _sz = 0;
	if (_sz < size)
	{
		a[_sz] = data;
		_sz++;
	}
	else
	{
		printf("已满\n");
	}
}

void PopBack(int*a)
{
	if (_sz > 0)
	{
		_sz--;
	}
	else
	{
		printf("已经没有元素，无法再删除\n");
	}
}
void Print(int*a, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", a[i]);
	}
}



int main()
{
	int *p=(int*)malloc(sizeof(int)*2);
	int size = 2;
	printf("插入数据后：");
	PushBack(p, 3, 2);
	PushBack(p, 4, 2);
	Print(p, _sz);
	printf("删除一个数据后：");
	PopBack(p);
	Print(p, _sz);

	system("pause");
	return 0;
}

运行结果：

如上图所示，我们在main函数中动态开辟一块内存空间，然后利用两个函数实现了“插入”和“删除”。但是仔细观察,函数的参数繁多，而且由于无论做什么操作，始终要知道当前空间里已有的元素个数，PushBack时空间已满则无法插入数据，PopBack时空间内要是没有元素显然也不存在删除。所以需要一个变量时刻记录当前空间元素个数情况，而且任意一个操作都会对它有影响，所以这里我们需要定义一个全局变量_sz。

好了，是不是很麻烦？参数一堆而且有了全局变量程序也变得危险，因为任何一个地方一不小心都会修改掉。此外，在main函数中，malloc开辟空间的大小其实是固定的--size。也代表了容量。如果数据量很大，那么这种方式显然会很麻烦。

于是，封装成结构体这种方式就很方便，_sz就相当于结构体中的_size（记录了当前空间的元素个数），_capacity就相当于上述代码malloc中的参数size（容量）。

下面是动态顺序表的实现-->

SeqList.h

#pragma once
typedef int DataType;
typedef struct SeqList
{
	DataType*_pData;
	int _capacity;//容量
	int _size;//有效元素的个数

}SeqList;

void SeqListInit(SeqList*pSeq,int capacity);//初始化顺序表
void PushBack(SeqList*pSeq, DataType data);//尾插
void PopBack(SeqList*pSeq);//尾删
void PushFront(SeqList*pSeq, DataType data);//头插
void PopFront(SeqList*pSeq);//头删
void SeqListInsert(SeqList*pSeq, int pos, DataType data);//在指定位置插入元素
void SeqListErase(SeqList*pSeq, int pos);//在指定位置删除元素
int SeqListFind(SeqList*pSeq, DataType data); //在顺序表中找data元素第一次出现的位置
void SeqListRemove(SeqList*pSeq, DataType data);// 删除顺序表中(第一次出现）的值为data的元素
int SeqListSize(SeqList*pSeq);//获取顺序表中有效元素的个数
int SeqListCapacity(SeqList*pSeq);//获取顺序表的容量
DataType SeqListFront(SeqList*pSeq);// 获取顺序表中第一个元素
DataType SeqListListBack(SeqList*pSeq);//获取顺序表中最后一个元素
void SeqListDestory(SeqList*pSeq);//销毁顺序表
void SeqListClear(SeqList*pSeq);//清空顺序表
void _CheckCapacity(SeqList*pSeq);//检测容量
void SeqListRemoveAll(SeqList*pSeq, DataType data);//删除顺序表中所有值为data的元素
void BubbleSort(SeqList*pSeq);//用冒泡排序的方式对顺序表中的元素进行排序
void Print(SeqList*pSeq);

SeqList.c

#include"SeqList.h"
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>


//初始化
void SeqListInit(SeqList*pSeq, int capacity)
{
	assert(pSeq);
	pSeq->_pData = (DataType*)malloc(sizeof(int)* capacity);
	if (pSeq->_pData == NULL)
	{
		printf("开辟空间失败!!!\n");
		exit(1);
	}
	pSeq->_size = 0;
	pSeq->_capacity = capacity;
}
//尾插
void PushBack(SeqList*pSeq, DataType data)
{
	//检测容量_CheckCapacity
	_CheckCapacity(pSeq);
	pSeq->_pData[pSeq->_size] = data;
	pSeq->_size++;
}
//尾删
void PopBack(SeqList*pSeq)
{
	assert(pSeq);
	if (pSeq->_size == 0)
	{
		printf("已空\n");
		exit(1);
	}
	pSeq->_size--;
}
//头插
void PushFront(SeqList*pSeq, DataType data)
{
	assert(pSeq);
	//检测容量_CheckCapacity
	//元素依次向后搬移
	for (int i = pSeq->_size - 1; i >= 0; i--)//i代表元素
	{
		pSeq->_pData[i + 1] = pSeq->_pData[i];
	}
	pSeq->_pData[0] = data;
	pSeq->_size++;
}

//头删
void PopFront(SeqList*pSeq)
{
	assert(pSeq);
	if (pSeq->_size == 0)
	{
		printf("已空！！\n");
		exit(1);
	}
	//元素依次向前搬移
	for (int i = 1; i < pSeq->_size; i++)
	{
		pSeq->_pData[i - 1] = pSeq->_pData[i];
	}
	pSeq->_size--;
}

//在指定位置插入元素
void SeqListInsert(SeqList*pSeq, int pos, DataType data)
{
	assert(pSeq);
	//检测容量_CheckCapacity
	if (pos<0 || pos>pSeq->_size)
	{
		printf("插入位置有误\n");
		return;
	}
	//先将pos位置后的元素依次向后搬移
	for (int i = pSeq->_size - 1; i >= pos; i--)
	{
		pSeq->_pData[i + 1] = pSeq->_pData[i];
	}
	pSeq->_pData[pos] = data;
	pSeq->_size++;
}


//在指定位置删除元素
void SeqListErase(SeqList*pSeq, int pos)
{
	assert(pSeq);
	//检测容量_CheckCapacity
	if (pos<0 || pos>pSeq->_size)
	{
		printf("删除位置有误\n");
		return;
		//exit(1);//这里究竟应该用哪个？
	}
	//先将pos位置后的元素依次向前搬移
	for (int i = pos; i < pSeq->_size - 1; i++)
	{
		pSeq->_pData[i] = pSeq->_pData[i + 1];
	}
	pSeq->_size--;
}


//在顺序表中找data元素第一次出现的位置
int SeqListFind(SeqList*pSeq, DataType data)
{
	assert(pSeq);
	if (pSeq->_size == 0)
	{
		printf("顺序表为空，无法查找元素\n");
		return;//这里用return还是exit?
	}
	for (int i = 0; i < pSeq->_size; i++)
	{
		if (pSeq->_pData[i] == data)
		{
			return i;
		}
	}
	return -1;//没有找到元素
}

// 删除顺序表中(第一次出现）的值为data的元素
void SeqListRemove(SeqList*pSeq, DataType data)
{
	//思路：先查找该元素，找到则删，删可以调用之前写的函数
	assert(pSeq);
	int pos = SeqListFind(pSeq, data);
	if (pos != -1)
	{
		SeqListErase(pSeq, pos);
	}
	//这里要不要写这条else语句？如果写了的话SeqListRemoveAll调用时删完后会找不到元素会一直输出
	/*else
	{
	printf("查无此元素，无法删除\n");
	}*/
}


//获取顺序表的容量
int SeqListCapacity(SeqList*pSeq)
{
	assert(pSeq);
	return pSeq->_capacity;
}


//获取顺序表中有效元素的个数
int SeqListSize(SeqList*pSeq)
{
	assert(pSeq);
	return pSeq->_size;
}


// 获取顺序表中第一个元素
DataType SeqListFront(SeqList*pSeq)
{
	assert(pSeq);
	if (pSeq->_size == 0)
	{
		printf("已空,无法获取\n");
		return;//这里用return还是exit?
	}
	return pSeq->_pData[0];

}

//获取顺序表中最后一个元素
DataType SeqListListBack(SeqList*pSeq)
{
	assert(pSeq);
	if (pSeq->_size == 0)
	{
		printf("已空,无法获取\n");
		return;//这里用return还是exit?
	}
	return pSeq->_pData[pSeq->_size - 1];
}


//销毁顺序表
void SeqListDestory(SeqList*pSeq)
{
	free(pSeq->_pData);
	pSeq->_capacity = 0;
	pSeq->_size = 0;
}
//清空顺序表
void SeqListClear(SeqList*pSeq)
{
	assert(pSeq);
	pSeq->_size = 0;
}


//检测容量
void _CheckCapacity(SeqList*pSeq)
{
	//思路：如果_size==_capacity，说明已满，需要扩容;这里每次扩容都扩大2倍
	//注意:扩容时容量最好定义一个新的变量来接收，不然很容易扩完后忘记更新当前容量
	assert(pSeq);
	if (pSeq->_size == pSeq->_capacity)
	{
		int New_capacity = pSeq->_capacity * 2;
		DataType*pNew = (DataType*)malloc(sizeof(DataType)*New_capacity);
		if (pNew == NULL)
		{
			printf("内存空间不足，开辟失败！！！\n");
			exit(1);//这里用return还是exit?
		}
		memcpy(pNew, pSeq->_pData, sizeof(DataType)*pSeq->_capacity);
		free(pSeq->_pData);
		pSeq->_pData = pNew;

		//扩容后更新当前的容量
		pSeq->_capacity = New_capacity;
	}
}

//删除顺序表中所有值为data的元素
//方法一：每次找到一个，则删除；缺点：每次都要从头开始遍历，时间复杂度太高
//void SeqListRemoveAll(SeqList*pSeq, DataType data)
//{
//	assert(pSeq);
//	for (int i = 0; i < pSeq->_size; i++)
//	{
//		SeqListRemove(pSeq, data);
//	}
//}

//删除顺序表中所有值为data的元素
//方法二：借助辅助空间
//开辟n个元素的空间，整体遍历一遍元素序列，
//（1）如果是要删除的元素，就不管；
//（2）如果不是要删除的元素，拷贝到新数组；
//最后再把新空间的元素都拷贝到原空间，再释放新开辟的空间
//void SeqListRemoveAll(SeqList*pSeq, DataType data)
//{
//	if (pSeq == NULL)
//	{
//		exit(0);
//	}
//	DataType*pData = (DataType*)malloc(sizeof(DataType)*pSeq->_size);
//	int count = 0;
//	for (int i = 0; i < pSeq->_size; i++)
//	{
//		if (pSeq->_pData[i] != data)
//		{
//			pData[count] = pSeq->_pData[i];
//			count++;
//		}
//	}
//	memcpy(pSeq->_pData, pData, sizeof(DataType)*count);
//	pSeq->_size =count;
//	free(pData);
//}



//删除顺序表中所有值为data的元素
//方法三：不需要借助任何辅助空间，效率最高
//定义一个计数器，记录当前遇到的要删除的元素的个数
//（1）遇到：说明之后的元素要搬移；count记录搬移次数
//（2）没遇到：说明之后的元素不搬移，当前元素向前搬移i - count
void SeqListRemoveAll(SeqList*pSeq, DataType data)
{
	if (pSeq == NULL)
	{
		exit(0);
	}
	int count = 0;//记录要删除的元素出现的个数
	for (int i = 0; i < pSeq->_size; i++)
	{
		
		if (pSeq->_pData[i] == data)
		{
			count++;
		}
		else
		{
			pSeq->_pData[i - count] = pSeq->_pData[i];
		}
	}
	pSeq->_size -= count;
}

//用冒泡排序的方式对顺序表中的元素进行排序
void BubbleSort(SeqList*pSeq)
{
	assert(pSeq);
	for (int i = 0; i < pSeq->_size - 1; i++)
	{
		for (int j = 0; j < pSeq->_size - 1 - i; j++)
		{
			if (pSeq->_pData[j]>pSeq->_pData[j + 1])
			{
				DataType tmp = pSeq->_pData[j];
				pSeq->_pData[j] = pSeq->_pData[j + 1];
				pSeq->_pData[j + 1] = tmp;
			}

		}
	}
}
//打印
void Print(SeqList*pSeq)
{
	for (int i = 0; i < pSeq->_size; i++)
	{
		printf("%d ", pSeq->_pData[i]);
	}
	printf("\n");
}

test.c

#include"SeqList.h"
#include<stdio.h>
#include<stdlib.h>


int main()
{
	SeqList sq;
	SeqListInit(&sq, 3);
	PushBack(&sq, 1);
	PushBack(&sq, 2);
	PushBack(&sq, 3);
	PushBack(&sq, 2);
	PushBack(&sq, 5);
	PushBack(&sq, 2);
	PushBack(&sq, 7);
	PushBack(&sq, 8);
	PushBack(&sq, 9);
	Print(&sq);
	//SeqListRemoveAll(&sq, 2);
	BubbleSort(&sq);
	Print(&sq);



	Print(&sq);
	///*PopBack(&sq);
	//PopBack(&sq);
	//Print(&sq);*/
	//PushFront(&sq, 4);
	//PushFront(&sq, 5);
	//Print(&sq);
	PopFront(&sq);
	//SeqListInsert(&sq, 1, 6);
	//SeqListInsert(&sq, 2, 6);
	//Print(&sq);
	//SeqListErase(&sq, 2);
	//Print(&sq);
	///*int ret = SeqListFind(&sq, 1);
	//printf("%d ", ret);*/
	//SeqListRemove(&sq, 6);
	//Print(&sq);

	//int size = SeqListSize(&sq);
	//printf("size=%d\n", size);

	//int capacity = SeqListCapacity(&sq);
	//printf("capacity =%d\n", capacity);

	//int data_front = SeqListFront(&sq);
	//printf("dada_front =%d\n", data_front);

	//int data_back = SeqListListBack(&sq);
	//printf("dada_back =%d\n", data_back);


	SeqListClear(&sq);
	//SeqListDestory(&sq);
	//Print(&sq);

	
	system("pause");
	return 0;
}

melody_jae

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
动态顺序表

我们对静态顺序表可能比较熟悉，它的定义方式是struct SeqList{ int arr[100]; int _size;//当前存放数据的个数};主要思想就是利用数组可以一次性开辟一整块空间，存放我们想要的数据。从这个结构体的定义，我们可以获得如下信息：开辟的空间大小为100，（即可以存放100个整型数据），_size记录了当前数组中有效元素的个数，为什么要有这一...
复制链接

扫一扫