数据结构：实现动态顺序表的各项接口（初始化，销毁，尾插尾删，头插头删，删除，排序，查找等）

最新推荐文章于 2022-11-03 19:44:59 发布
最新推荐文章于 2022-11-03 19:44:59 发布
阅读量381 收藏 2
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ETalien_/article/details/83662082
版权

实现动态顺序表

顺序表概念及结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
顺序表一般可以分为：
1.静态顺序表：使用定长数组存储。
在这里插入图片描述
2.动态顺序表：使用动态开辟的数组存储。
在这里插入图片描述

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多 了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。具体代码如下：

SeqList.h

#pragma once

静态顺序表
//#define N 10
//typedef int SLDateType;
//typedef struct SeqList
//{
//	int _a[N];//数组
//	size_t _size;//有多少个有效数据
//}SeqList;
//

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <malloc.h>

//动态顺序表
#define N 10
typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* _a;   //数组
	size_t _size;     //有多少个有效数据
	size_t _capacity;  //容量
}SeqList;

void CheckCapacity(SeqList* psl);
void SeqListInit(SeqList* psl, size_t capacity);//初始化
void SeqListDestory(SeqList* psl);//销毁

void SeqListPushBack(SeqList* psl, SLDateType x);//尾插
void SeqListPopBack(SeqList* psl);//尾删
void SeqListPushFront(SeqList* psl, SLDateType x);//头插
void SeqListPopFront(SeqList* psl);//头删

void SeqListInsert(SeqList* psl, size_t pos, SLDateType x);//任意位置的插入,在pos位置上的插入
void SeqListErase(SeqList* psl, size_t pos);//删除pos这个位置的数据
void SeqListRemove(SeqList* psl, SLDateType x);//删除x这个数据
int SeqListFind(SeqList* psl, SLDateType x);//查找一个数据
void SeqListModify(SeqList* psl, size_t pos, SLDateType x);//修改pos位置的值，修改为x

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

void SeqListBubbleSort(SeqList* psl);//冒泡排序
void SeqListSelectSort(SeqList* psl);//选择排序
int SeqListBinarySearch(SeqList* psl,SLDateType x); //二分查找
void SeqListRemoveAll(SeqList* psl,SLDateType x);//删除所有的x

void TestSeqList();//测试函数

SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "SeqList.h"

void CheckCapacity(SeqList* psl)//检查容量
{
	assert(psl);
	if (psl->_capacity == psl->_size)
	{
		if (psl->_capacity == 0)
		{
			psl->_capacity = 2;
		}
		SLDateType* tmp = realloc(psl->_a, psl->_capacity * 2 * sizeof(SLDateType));//增二倍
		assert(tmp);
		psl->_a = tmp;
		psl->_capacity *= 2;
	}
}

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

void SeqListInit(SeqList* psl, size_t capacity)//初始化
{
	assert(psl);
	if (capacity == 0)
	{
		psl->_capacity = 0;
		psl->_size = 0;
		psl->_a = NULL;
	}
	else
	{
		psl->_a = (SLDateType*)malloc(sizeof(SLDateType)*capacity);
		assert(psl->_a);
		psl->_capacity = capacity;
		psl->_size = 0;
	}
}

void SeqListDestory(SeqList* psl)//销毁顺序表
{
	assert(psl);
	free(psl->_a);
	psl->_a = NULL;
	psl->_capacity = 0;
	psl->_size = 0;
}

void SeqListPushBack(SeqList* psl, SLDateType x)//尾插
{
	assert(psl);

	CheckCapacity(psl);

	psl->_a[psl->_size] = x;
	psl->_size++;
	
	//SeqListInsert(psl, psl->_size, x);
}

void SeqListPopBack(SeqList* psl)//尾删
{
	assert(psl);
	if (psl->_size > 0)
	{
		psl->_size--;
	}

	//SeqListErase(psl, psl->_size);
}

void SeqListPushFront(SeqList* psl, SLDateType x)//头插
{
	assert(psl);

	CheckCapacity(psl);

	int end = psl->_size;
	while (end >= 0)
	{
		psl->_a[end + 1] = psl->_a[end];
		end--;
	}
	psl->_a[0] = x;
	psl->_size++;

	//SeqListInsert(psl, 0, x);
}

void SeqListPopFront(SeqList* psl)//头删
{
	assert(psl);
	if ((psl->_size) > 0)
	{
		int start = 0;
		while (start < (int)(psl->_size-1))
		{
			psl->_a[start] = psl->_a[start + 1];
			start++;
		}
		psl->_size--;
	}

	//SeqListErase(psl, 0);
}

void SeqListInsert(SeqList* psl, size_t pos, SLDateType x)//任意位置的插入,在pos位置上的插入
{
	assert(psl && pos <= (psl->_size));//pos=size可以理解为尾插
	int end = psl->_size - 1;

	CheckCapacity(psl);

	while (end >= (int)pos)
	{
		psl->_a[end + 1] = psl->_a[end];
		end--;
	}
	psl->_a[pos] = x;
	psl->_size++;
}

void SeqListErase(SeqList* psl, size_t pos)//删除pos这个位置的数据
{
	assert(psl && pos <= (psl->_size));
	int start = pos;
	while (start < (int)(psl->_size - 1))
	{
		psl->_a[start] = psl->_a[start + 1];
		start++;
	}
	psl->_size--;
}

int SeqListFind(SeqList* psl, SLDateType x)//查找一个数据
{
	assert(psl);
	size_t i = 0;
	for (i = 0; i < (psl->_size); i++)
	{
		if (psl->_a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

void SeqListRemove(SeqList* psl, SLDateType x)//删除x这个数据
{
	assert(psl);
	int pos = SeqListFind(psl, x);
	if (pos != -1)
	{
		SeqListErase(psl, pos);
	}
}

void SeqListModify(SeqList* psl, size_t pos, SLDateType x)//修改pos位置的值，修改为x
{
	assert(psl && pos<(psl->_size));
	psl->_a[pos] = x;
}

void SeqListBubbleSort(SeqList* psl)//冒泡排序
{
	assert(psl);
	size_t i = 0;
	size_t j = 0;
	int flag = 0;
	for (i = 0; i < psl->_size - 1; i++)
	{
		flag = 0;
		for (j = 0; j < psl->_size - 1 - i; j++)
		{
			if (psl->_a[j] > psl->_a[j + 1])
			{
				SLDateType tmp = psl->_a[j];
				psl->_a[j] = psl->_a[j + 1];
				psl->_a[j + 1] = tmp;
				flag = 1;
			}
		}
		if (flag = 0)
		{
			break;
		}
	}
}

void Swap(SLDateType* x, SLDateType* y)//交换函数
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

void SeqListSelectSort(SeqList* psl)//选择排序
{
	assert(psl);
	int begin = 0;
	int end = psl->_size - 1;
	while (begin < end)
	{
		int min = begin;
		int max = begin;
		for (int i = begin; i < end; i++)
		{
			if (psl->_a[i] < psl->_a[min])
			{
				min = i;
			}
			if (psl->_a[i] > psl->_a[max])
			{
				max = i;
			}
		}
		Swap(&psl->_a[begin], &psl->_a[min]);
		if (begin == max)
		{
			max = min;
		}
		Swap(&psl->_a[end], &psl->_a[max]);
		begin++;
		end--;
	}
}

int SeqListBinarySearch(SeqList* psl,SLDateType x) //二分查找
{
	assert(psl);
	size_t left = 0;
	size_t right = psl->_size - 1;
	while (left <= right)
	{
		int mid = left + (right - left) / 2;
		if (psl->_a[mid] == x)
		{
			return mid;
		}
		if (psl->_a[mid] > x)
		{
			right = mid - 1;
		}
		if (psl->_a[mid] < x)
		{
			left = mid + 1;
		}
	}
	return -1;
}

void SeqListRemoveAll(SeqList* psl, SLDateType x)//删除所有的x
{
	assert(psl);
	size_t i = 0;
	while (i < psl->_size-1)
	{
		int cur = SeqListFind(psl, x);
		if (cur != -1)
		{
			SeqListRemove(psl, x);
		}
		i++;
	}

}

void TestSeqList()//测试
{
	SeqList sl;
	SeqListInit(&sl, 5);
	SeqListPushBack(&sl, 1);//尾插1
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPushBack(&sl, 6);
	SeqListPushBack(&sl, 7);
	SeqListPopBack(&sl);//尾删
	SeqListPrint(&sl);

	SeqListPushFront(&sl, 50);//头插50
	SeqListPushFront(&sl, 50);
	SeqListPopFront(&sl);//头删
	SeqListPrint(&sl);

	SeqListInsert(&sl, 4, 100);//在下标为4的数据前添加数据100
	SeqListPrint(&sl);

	SeqListErase(&sl, 6);//删除下标为6的数据
	SeqListPrint(&sl);

	SeqListRemove(&sl, 2);//删除2
	SeqListPrint(&sl);

	SeqListModify(&sl, 3, 2);
	SeqListPrint(&sl);

	//SeqListBubbleSort(&sl);//冒泡排序
	SeqListSelectSort(&sl);//选择排序
	SeqListPrint(&sl);

	int sub = SeqListBinarySearch(&sl, 2);//二分查找数据2
	if (sub != -1)
	{
		printf("找到了，下标为：%d\n", sub);
	}

	SeqListRemoveAll(&sl, 3);//删除所有3
	SeqListPrint(&sl);

	SeqListDestory(&sl);//销毁该顺序表
}

Main.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "SeqList.h"
int main()
{
	TestSeqList();
	system("pause");
	return 0;
}
ETalien_
关注
专栏目录
顺序表销毁
骆驼胡杨的博客
07-24 3312
顺序表销毁之后不可进行添加数据, 插入数据, 以及删除数据等操作 #include <iostream> #include <Windows.h> #include <string> using namespace std; #define MAX_SIZE 100 typedef struct { int *elems; //顺序表的基地址 int length; //顺序表的长度 int size; //顺序表总空间大小 } Sqlist; boo
顺序表的相关操作 头插，尾插，头删，尾删，任意位置插入删除
weixin_43962381的博客
12-08 2426
顺序表的相关操作 头插，尾插，头删，尾删，任意位置插入删除 #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<string.h> #include<stdlib.h> typedef int slDatatype;//顺序表内的数据类型（便于维护） //动态顺序表 typedef struct seqList { slDatatype *data; //数组指针 int size;
顺序表动态创建和初始化
一个随时准备弃坑的博客
03-18 1666
#include<stdio.h> #include<stdlib.h> #define InitSize 10 //默认的最大长度 typedef struct { int *data; //指示动态分配数组的指针 int MaxSize;//顺序表的最大容量 int length; //顺序表的当前长度 }SeqList; void Init...
数据结构顺序表初始化
09-12
数据结构 是个指针变量,实际的意思是指向一个内存地址,当p=(char *)malloc(2) 后,p即指向了malloc函数所分配的内存区的首地址了,并且告诉你从首地址
C语言：【动态顺序表】动态顺序表的初始化、打印、尾插PushBack、尾删PopBack
hanjing_1995的博客
05-30 418
#include #include #include #include #include typedef int DateType; typedef struct SeqList {     DateType *arr;     size_t capacility;     size_t size; }SeqList; //创建空间 void CheckCapa(SeqList *Seq)
数据结构的顺序存储结构——顺序表(一) 顺序表的初始化（C语言）
weixin_43903780的博客
10-30 5600
顺序存储结构 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 初 初始化 使用顺序表存储数据： 1.要申请足够大小的物理空间； 2.顺序表申请的存储容量； 3.顺序表的长度，也就是表中存储数据元素
数据结构与算法——顺序表 (完整代码)
zz137955的博客
10-31 2008
基于语言实现数据结构第一节——顺序表 增删查改
【数据结构入门】带头双向循环链表（List）详解（定义、增、删、查、改） | 配有大量图解，超详细哦~
codewinter的博客
09-10 2490
文章目录（1）前言（2）带头双向循环链表的实现1）双向链表的定义2）双向链表的初始化3）双向链表的销毁4）打印双向链表5）双向链表的尾插6）双向链表的尾删7）双向链表的头插8）双向链表的头删9）查找双向链表中的元素10）在指定pos位置之前插入元素11）删除指定pos位置的元素12）双向链表的判空13）获取双向链表的元素个数 学习双向链表之前，建议先学习下顺序表和单链表，配合这两篇文章食用更佳哦： 【数据结构入门】顺序表（SeqList）详解（初始化、增、删、查、改） 【数据结构入门】无头单向非循环链表（S
[数据结构]数据结构简介和顺序表
最新发布
carry_carial的博客
11-03 1032
今天正式第一节数据结构，我们从顺序表开始讲起，和小明和小亮一起打开数据结构之路---顺序表
【数据结构】顺序表
knous
03-10 2146
顺序表
C++顺序表基本操作 初始化 插入 删除 输出 销毁
03-17
C++顺序表基本操作 初始化 插入 删除 输出 销毁
数据结构专题(一）：1.1顺序表初始化
weixin_43907175的博客
12-26 721
顺序表有以下特性： (1)初始化 (2)增删改查 (3)遍历读取 如下代码： 头文件.h #pragma once #include <stdio.h> #include <stdlib.h> typedef int ElemType; //假定线性表的元素类型为整型，方便以后转换类型 #define LIST_SIZE 1024//假定我们的线性表长度是1024 typedef struct{ ElemType data[LIST_SIZE]; int last;
数据结构——顺序表初始化及基操
yyy_zxc的博客
10-21 406
//头文件 #include <stdio.h> #include <stdlib.h> #define MaxSize 10 #define TypeEle int //定义顺序表 //静态分配（数组） typedef struct{ TypeEle data[MaxSize]; //存储数据 TypeEle length; //当前长度 }SqList; //动态分配（指针） typedef struct{ TypeEle ...
数据结构与算法——顺序表的初始化和增删查改
交流问题可联系 shuangc1314@foxmail.com
09-04 564
数据结构与算法——顺序表的初始化和增删查改
补上之前动态顺序表的初始化及基本操作
qq_39428110的博客
06-05 264
补上之前动态顺序表的初始化，实现语言依旧是C，注释都已经标注在代码中 /* 陈卓阳 2020年5月14日20:03:57 顺序表的基本操作(初始化，扩容，插入，删除，查找) */ #include <stdio.h> #include <stdlib.h> #define InitSize 10 //默认的最大长度 typedef struct { int *data; int MaxSize; //顺序表最大容量 int length; //顺序表的当前长度 }*PSqLis
数据结构—顺序表的销毁
qq_39830449的博客
08-20 1万+
//顺序表的销毁 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define OK 1 #define OVERFLOW -2 #define LIST_INIT_SIZE 10// 线性表存储空间的初始分配量 typedef int Status; //Status是函数数据类型 ，其值是函数结果状态，如OK typedef ...
线性表之顺序表的创建 初始化 查找 删除 插入和合并
qq_43685243的博客
11-15 976
线性表之顺序表的创建 初始化 查找 删除 插入和合并
顺序表——动态分配顺序表上的基本操作（初始化、遍历、插入、查找、删除、判空等）
薛定谔的猫的博客
04-15 4709
文章目录顺序表的定义顺序表上的操作初始化求表长遍历表动态分配插入操作查找操作按值查找按位查找删除操作判空操作销毁操作完整代码及实例 顺序表的定义  线性表的顺序存储又称顺序表。它是用一组地址连续的存储单元依次存储线性表中的数据元素，使得逻辑上相邻的两个元素在物理位置上也相邻。  顺序表的特点： 随机访问。通过首地址和元素序号可在时间O（1）内找到指定元素。 存储密度高。每个结点只存储数据元素。 逻辑上相邻的元素在物理上也相邻，故插入和删除操作需要移动大量元素。 顺序表上的操作  在顺序表上的操作主要有：
【数据结构入门】顺序表（SeqList）详解（初始化、增、删、查、改）
热门推荐
codewinter的博客
08-18 7万+
文章目录（1）线性表（2）顺序表1）什么是顺序表2）顺序表的定义2）顺序表的接口实现1、初始化顺序表2、销毁（释放）顺序表3、检查顺序表容量是否满了，好进行增容3、顺序表尾插4、顺序表尾删5、顺序表头插6、顺序表头删7、打印顺序表8、在顺序表中查找指定值9、在顺序表指定下标位置插入数据10、在顺序表中删除指定下标位置的数据11、查看顺序表中有效数据个数12、修改指定下标位置的数据 （1）线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结
链表操作实现：初始化、头插法、尾插法、查找与删除
"链表建立和基本操作包括创建链表（从头或尾部插入元素）、删除元素、插入元素、置空链表以及查找元素。本文档提供的代码示例是用...在实际编程中，理解并掌握这些概念对于处理动态数据集和实现高效数据结构至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值