顺序表C语言实现

最新推荐文章于 2023-10-04 21:03:00 发布
最新推荐文章于 2023-10-04 21:03:00 发布
阅读量103 收藏 1
点赞数
分类专栏： 数据结构和算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51765966/article/details/120356455
版权

顺序表

1.顺序表的特性

存储的数据类型相同；
存储单元的物理地址连续；
支持根据下标随机访问；

2.顺序表的类型

1)静态顺序表

存储的数据个数有上限，一般是用一个大小固定的数组实现,实用性不高;

2）动态顺序表

数据的存储空间可以随着元素个数的增加而调整，当数据满了就会增容；

3.顺序表模拟实现

1)静态顺序表

数据结构如下:

//顺序表大小
#define MAXSZ 8
typedef int DataType;	//数据元素类型

typedef struct StaticList
{
	DataType data[MAXSZ];			//数据域
	int size;		//有效元素个数
}StaticList;
重要的接口:
初始化顺序表

设置当前有效元素个数为0

void Init(StaticList* lst)
{
	lst->size = 0;
}
插入

将待插入位置和其后面的元素都往后移动一位，再将数据放入插入位置，有效元素个数加1

bool Insert(StaticList* lst, int pos, DataType val)
{
	//检查位置的有效性
	if (pos < 0 || pos >= MAXSZ)
	{
		return false;
	}

	//检查空间是否足够
	if (lst->size + 1 > MAXSZ)
		return false;

	//移动元素
	for (int i = MAXSZ - 1; i > pos; --i)
	{
		lst->data[i] = lst->data[i - 1];
	}

	//插入数据,更新有效元素个数
	lst->data[pos] = val;
	lst->size++;

	return true;
}
删除

将待删除位置后面的所有元素都往前移动一位，有效元素个数减1

bool Erase(StaticList* lst, int pos)
{
	//检查位置的有效性
	if (pos < 0 || pos >= MAXSZ)
		return false;

	//尾删不需要移动元素
	//不是尾删需要移动元素
	if (pos != MAXSZ - 1)
	{
		//移动元素
		for (int i = pos; i < MAXSZ - 1; i++)
		{
			lst->data[i] = lst->data[i + 1];
		}
	}

	//更新有效元素个数
	lst->size--;
	return true;
}
源码

StaticList.h:

#pragma once
//静态顺序表

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <limits.h> //INT_MIN
#include <stddef.h>		//int

//顺序表大小
#define MAXSZ 8
typedef int DataType;

typedef struct StaticList
{
	DataType data[MAXSZ];			//数据域
	int size;		//有效元素个数
}StaticList;

//初始化
void Init(StaticList* lst);

//插入
bool Insert(StaticList* lst, int pos, DataType val);

//删除
bool Erase(StaticList* lst, int pos);

//修改
bool SetValue(StaticList* lst, int pos, DataType val);

//获取元素
DataType getValue(StaticList* lst, int pos);

//查找
int Search(StaticList* lst, DataType val);

//头插
bool Push_front(StaticList* lst, DataType val);

//尾插
bool Push_back(StaticList* lst, DataType val);

//头删
bool Pop_front(StaticList* lst);

//尾删
bool Pop_back(StaticList* lst);

//有效元素个数
int getSize(StaticList* lst);

//顺序表是否为空
bool isEmpty(StaticList* lst);

//顺序表是否已满
bool isFull(StaticList* lst);

//打印顺序表内容
void PrintList(StaticList* lst);

StaticList.c:

#include "StaticList.h"


//初始化
void Init(StaticList* lst)
{
	lst->size = 0;
}

//插入
bool Insert(StaticList* lst, int pos, DataType val)
{
	//检查位置的有效性
	if (pos < 0 || pos >= MAXSZ)
	{
		return false;
	}

	//检查空间是否足够
	if (lst->size + 1 > MAXSZ)
		return false;

	//移动元素
	for (int i = MAXSZ - 1; i > pos; --i)
	{
		lst->data[i] = lst->data[i - 1];
	}

	//插入数据,更新有效元素个数
	lst->data[pos] = val;
	lst->size++;

	return true;
}

//删除
bool Erase(StaticList* lst, int pos)
{
	//检查位置的有效性
	if (pos < 0 || pos >= MAXSZ)
		return false;

	//尾删不需要移动元素
	//不是尾删需要移动元素
	if (pos != MAXSZ - 1)
	{
		//移动元素
		for (int i = pos; i < MAXSZ - 1; i++)
		{
			lst->data[i] = lst->data[i + 1];
		}
	}

	//更新有效元素个数
	lst->size--;
	return true;
}

//修改
bool SetValue(StaticList* lst, int pos, DataType val)
{
	//检查位置的有效性
	if (pos < 0 || pos >= MAXSZ)
		return false;

	lst->data[pos] = val;

	return true;
}

//获取元素
DataType getValue(StaticList* lst, int pos)
{
	if (pos < 0 || pos >= MAXSZ)
		return INT_MIN;

	return lst->data[pos];
}

//查找
int Search(StaticList* lst, DataType val)
{
	int ret = -1;
	for (int i = 0; i < MAXSZ; ++i)
	{
		if (lst->data[i] == val)
		{
			ret = i;
			break;
		}
	}
	return ret;
}

//头插
bool Push_front(StaticList* lst, DataType val)
{
	return Insert(lst, 0, val);
}

//尾插
bool Push_back(StaticList* lst, DataType val)
{
	return Insert(lst, lst->size, val);
}

//头删
bool Pop_front(StaticList* lst)
{
	return Erase(lst, 0);
}

//尾删
bool Pop_back(StaticList* lst)
{
	return Erase(lst, lst->size - 1);
}

//有效元素个数
int getSize(StaticList* lst)
{
	return lst->size;
}

//顺序表是否为空
bool isEmpty(StaticList* lst)
{
	return lst->size == 0;
}
 
//顺序表是否已满
bool isFull(StaticList* lst)
{
	return lst->size == MAXSZ - 1;
}

//打印顺序表内容
void PrintList(StaticList* lst)
{
	for (int i = 0; i < lst->size; ++i)
	{
		printf("%d ", lst->data[i]);
	}
	printf("\n");
}

2）动态顺序表

数据结构的定义
typedef int DataType_D;	//数据元素类型

//动态顺序表
typedef struct DynamicList
{
	DataType_D* data;		//数据
	int size;			//有效元素个数
	int capacity;		//最大容纳元素个数
}DynamicList;
重要接口
初始化顺序表

开辟固定大小的空间，为元素个数和容量赋初值；
起始开辟一定大小的空间，可以通过宏来设置

//初始化
bool InitList(DynamicList* lst)
{
	if (lst == NULL)
		return false;
	
	//startCapacity：起始容量
	lst->data = (DataType_D*)malloc(sizeof(DataType_D)* startCapacity);
	lst->size = 0;
	lst->capacity = startCapacity;
	return true;
}
销毁顺序表

释放堆空间，防止内存泄漏

bool DestroyList(DynamicList* lst)
{
	if (lst == NULL || lst->data == NULL)
		return true;
	free(lst->data);
	lst->data = NULL;
	return true;
}
检查容量

当顺序表满了，就重新开辟空间，并将原空间的数据拷贝过去，更新容量

//检查容量
void checkCapacity(DynamicList* lst)
{
	if (lst == NULL || lst->data == NULL || lst->size != lst->capacity)
		return;

	int newC = lst->capacity * 2;
	//重新开辟空间并拷贝原空间的数据
	lst->data = (DataType_D*)realloc(lst->data, newC * sizeof(DataType_D));

	/*
		//另一种重开空间并拷贝
		DataType_D* newData = (DataType_D*)malloc(sizeof(DataType_D) * newC);
		memcpy(newData, lst->data, sizeof(DataType_D) * lst->capacity());
		free(lst->data);
		lst->data = newData;
	*/

	//更新
	lst->capacity = newC;
}
插入

第一步：检查容量；
第二步：将待插入位置和它后面的元素都往后移动一位；
第三步：插入数据；
第四步：更新元素个数

//插入
bool InsertList(DynamicList* lst, int pos, DataType_D val)
{
	if (lst == NULL || lst->data == NULL || pos < 0 || pos > lst->capacity)
		return false;

	//检查容量
	checkCapacity(lst);

	if (pos > lst->size)
		pos = lst->size;

	//移动数据
	int idx = lst->size - 1;
	while (idx >= pos)
	{
		lst->data[idx + 1] = lst->data[idx];
		idx--;
	}

	//插入数据
	lst->data[pos] = val;

	//更新
	++lst->size;

	return true;
}
删除

将待删除位置后面的元素都往前移动一位，并更新元素个数

bool EraseList(DynamicList* lst, int pos)
{
	if (lst == NULL || lst->data == NULL || pos < 0 || pos >= lst->capacity)
		return false;

	//移动元素
	int idx = pos;

	while (idx < lst->size - 1)
	{
		lst->data[idx] = lst->data[idx + 1];
		idx++;
	}

	//更新
	--lst->size;

	return true;
}
源码

DynamicList.h:

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <limits.h>		//INT_MAX

typedef int DataType_D;	//数据元素类型
#define startCapacity 10	//起始容量

//动态顺序表
typedef struct DynamicList
{
	DataType_D* data;		//数据
	int size;			//有效元素个数
	int capacity;		//最大容纳元素个数
}DynamicList;

//初始化
bool InitList(DynamicList* lst);

//销毁顺序表，主要是释放堆上申请的空间
bool DestroyList(DynamicList* lst);

//检查容量
void checkCapacity(DynamicList* lst);

//插入
bool InsertList(DynamicList* lst, int pos, DataType_D val);

//删除
bool EraseList(DynamicList* lst, int pos);

//头插
bool pushFront(DynamicList* lst, DataType_D val);

//尾插
bool pushBack(DynamicList* lst, DataType_D val);

//头删
bool popFront(DynamicList* lst);

//尾删
bool popBack(DynamicList* lst);

//判空
bool IsEmpty(DynamicList* lst);

//打印顺序表
void printList(DynamicList* lst);

//根据值查找下标
int findIdx(DynamicList* lst, DataType_D val);

//根据下标查找值
DataType_D GetValue(DynamicList* lst, int pos);

//修改指定位置的值
bool setValue(DynamicList* lst, int pos, DataType_D val);

//获取有效元素个数
int getEleSize(DynamicList* lst);

//清空数据
void clearList(DynamicList* lst);

DynamicList.c:

#include "DynamicList.h"

//初始化
bool InitList(DynamicList* lst)
{
	if (lst == NULL)
		return false;
	
	//startCapacity：起始容量
	lst->data = (DataType_D*)malloc(sizeof(DataType_D)* startCapacity);
	lst->size = 0;
	lst->capacity = startCapacity;
	return true;
}

//销毁顺序表，主要是释放堆上申请的空间
bool DestroyList(DynamicList* lst)
{
	if (lst == NULL || lst->data == NULL)
		return true;
	free(lst->data);
	lst->data = NULL;
	return true;
}

//检查容量
void checkCapacity(DynamicList* lst)
{
	if (lst == NULL || lst->data == NULL || lst->size != lst->capacity)
		return;

	int newC = lst->capacity * 2;
	//重新开辟空间并拷贝原空间的数据
	lst->data = (DataType_D*)realloc(lst->data, newC * sizeof(DataType_D));

	/*
		//另一种重开空间并拷贝
		DataType_D* newData = (DataType_D*)malloc(sizeof(DataType_D) * newC);
		memcpy(newData, lst->data, sizeof(DataType_D) * lst->capacity());
		free(lst->data);
		lst->data = newData;
	*/

	//更新
	lst->capacity = newC;
}

//插入
bool InsertList(DynamicList* lst, int pos, DataType_D val)
{
	if (lst == NULL || lst->data == NULL || pos < 0 || pos > lst->capacity)
		return false;

	//检查容量
	checkCapacity(lst);

	if (pos > lst->size)
		pos = lst->size;

	//移动数据
	int idx = lst->size - 1;
	while (idx >= pos)
	{
		lst->data[idx + 1] = lst->data[idx];
		idx--;
	}

	//插入数据
	lst->data[pos] = val;

	//更新
	++lst->size;

	return true;
}

//删除
bool EraseList(DynamicList* lst, int pos)
{
	if (lst == NULL || lst->data == NULL || pos < 0 || pos >= lst->capacity)
		return false;

	//移动元素
	int idx = pos;

	while (idx < lst->size - 1)
	{
		lst->data[idx] = lst->data[idx + 1];
		idx++;
	}

	//更新
	--lst->size;

	return true;
}

//头插
bool pushFront(DynamicList* lst, DataType_D val)
{
	return InsertList(lst, 0, val);
}

//尾插
bool pushBack(DynamicList* lst, DataType_D val)
{
	return InsertList(lst, lst->size, val);
}

//头删
bool popFront(DynamicList* lst)
{
	return EraseList(lst, 0);
}

//尾删
bool popBack(DynamicList* lst)
{
	return EraseList(lst, lst->size);
}

//判空
bool IsEmpty(DynamicList* lst)
{
	return lst == NULL || lst->data == NULL || lst->size == 0;
}

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

//根据值查找下标:返回-1表示没找到
int findIdx(DynamicList* lst, DataType_D val)
{
	if (lst == NULL || lst->data == NULL)
		return -1;

	for (int i = 0; i < lst->size; ++i)
	{
		if (lst->data[i] == val)
		{
			return i;
		}
	}
	return -1;	
}

//根据下标查找值
//约定没找到返回INT_MAX

DataType_D GetValue(DynamicList* lst, int pos)
{
	if (lst == NULL || lst->data == NULL)
		return INT_MAX;

	if (pos < 0 || pos >= lst->size)
		return INT_MAX;
	return lst->data[pos];
}

//修改指定位置的值
bool setValue(DynamicList* lst, int pos, DataType_D val)
{
	if (lst == NULL || lst->data == NULL || pos < 0 || pos >= lst->size)
		return false;
	lst->data[pos] = val;
	return true;
}


//获取有效元素个数
int getEleSize(DynamicList* lst)
{
	if (lst == NULL || lst->data == NULL)
		return 0;
	return lst->size;
}

//清空数据
void clearList(DynamicList* lst)
{
	lst->size = 0;
}

4.顺序表的优缺点

优点：
尾插尾删效率高，时间复杂度为O(1)；
支持按照下标随机访问；
空间连续，不会造成内存碎片；
增容代价高，需要开辟新空间和拷贝数据；

缺点：
头部和中间位置的插入和删除操作都需要移动元素，时间复杂度为O(N)；
空间利用率不高，顺序表的空间可能会因为元素个数较小而被浪费

cxpxatu521
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之线性表
qq_43607916的博客
10-05 281
线性表 文章目录： 线性表的定义 线性表的基本操作 顺序表的定义 顺序表的两种实现方式 顺序表的基本操作 其他笔记的总结 3.顺序表的定义 4.顺序表的两种实现方式 静态分配 动态分配 5.顺序表的基本操作 插入 删除 按位查找 按值查找 6.其他笔记的总结 以上是顺序表的内容，之后会更新单链表的相关知识内容。 ...
C语言实现顺序表的合并
12-23
C语言数据结构实现顺序表的动态申请内存并且合并，代码可以直接使用。
【数据结构】——顺序表介绍（独家介绍，小白必看！！）
yakiyakiya的博客
09-04 8763
数据结构入门级别的线性表——顺序表，内含独家理解，讲解详细，满满干货，放心食用！
详解顺序表 数据结构
weixin_53618261的博客
10-04 526
什么是顺序表顺表是一种线性结构，它使用一段连续的物理地址存储单元来存储数据元素，并一般采用数组的形式进行存储和操作。顺序表可以轻松地进行数据的插入、删除、查找和修改操作。通过使用数组实现，顺序表充分利用了数组的随机访问特性，使得操作效率较高。顺序表的操作主要涉及到对数组的插入和删除操作时，需要移动元素的位置，以保持顺序表的连续性。此外，顺序表的长度可以动态调整，可以根据实际需求进行扩容或缩容。//数组data用于存放表节点，ListSize表示数组大小int length;//表示当前表长度。
【数据结构】顺序表
m0_56138343的博客
07-27 139
顺序表是非常简单的一种数据结构，其是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储在数组上完成数据的增删查改。顺序表的结构就是连续存储，牵一发动全身，尤其是插入元素的时候，动一个元素就要将其相邻元素移位，这个过程不难，根据代码阅读一遍基本就可以掌握了，下期见，salute！
数据结构与算法之————————线性表①顺序表
qq_16069927的博客
08-23 406
1、顺序表的两种基本形式（其查找元素的时间复杂度是O（1））   图a表示的是顺序表的基本形式，数据元素本身连续存储，每个元素所占的存储单元大小固定相同，元素的下标是其逻辑地址，而元素存储的物理地址（实际内存地址）可以通过存储区的起始地址Loc (e0)加上逻辑地址（第i个元素）与存储单元大小（c）的乘积计算而得，即： Loc(ei) = Loc(e0) + c*i 故，访问指定元素...
顺序表C语言实现详解
hurryddd
04-03 2999
1、线性表 线性表。全名为线性存储结构，可以理解为即“把所有数据用一根线儿串起来，再存储到物理空间中”。线性表并不是一种具体的存储结构，它包含 顺序存储结构 和 链式存储结构，是顺序表和链表的统称。除了数组，链表、队列、栈等也是线性表结构。 顺序存储结构：将数据依次存储在连续的整块物理空间中 链式存储结构：数据分散的存储在物理空间中，通过一根线保存着它们之间的逻辑关系 非线性表。在非线性表中，数据之间并不是简单的前后关系。比如树、图 2、顺序表 它用一组连续的内存空间，来存储一组具有
顺序链表C语言实现
zcg_741454897的博客
11-04 3316
顺序链表没什么说的啦，直接上代码，参考了传智播客出版的数据结构。创建工程的时候不小心弄成c++了，不过没关系，都一样。 Operation中有一处语法上的疑惑，就是插入的那个函数中，node为什么要强制转换成整型，既然等式两边都是指针，为什么不是转化成int* ，有心人帮忙解答一下，谢谢。 SeqList.h头文件 #ifndef _SEQLIST_H_ #define _SEQLIST_...
C语言实现顺序表
辰多代码的博客
07-26 1874
1.2 SeqList.c 1.3 test.c 二、顺序表的实现 2.1 顺序表 创建一个顺序表结构体，成员包含顺序表地址、长度、大小，用于创建顺序表变量。 将顺序表变量的地址传参，通过指针接收对顺序表的顺序表数组初始化为空，长度为0，大小为0。 同样传地址，要先断言指针是否为空，不然会出异常。然后判断顺序表大小是否为0，为0则代表顺序表中没有有效元素，打印提示，并返回函数，如果大于0，则有元素，从下标0开始，打印size个顺序表元素，并用空格相隔。 当我们结束程序
顺序表-c语言实现
m0_46343224的博客
11-02 1194
c语言实现的顺序表，通俗易懂，相信你能舒服的看懂，有问题可以私信我。
C语言实现动态顺序表的实现代码
12-31
C语言实现动态顺序表的实现代码 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点...
C语言顺序表的实现代码
08-29
主要为大家详细介绍了C语言实现顺序表的实现代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C语言实现顺序表基本操作汇总
09-04
主要介绍了C语言实现顺序表基本操作汇总,对学习数据结构的朋友有一定的借鉴价值,需要的朋友可以参考下
C++进行迷宫问题求解
热门推荐
m0_51765966的博客
11-19 1万+
利用栈和队列两种数据结构实现迷宫求解一. 迷宫问题的描述二. 迷宫问题求解1.使用队列进行深度优先搜索C++代码实现2. 使用栈进行深度优先搜索C++代码实现3.代码运行结果三.迷宫问题小实验总结 一. 迷宫问题的描述 有一张地图，0表示没有障碍物，1表示有障碍物，给你一幅地图、一个起始位置和一个目标位置，请判断是否能够从起始位置出发到达目标位置，可以的话将走过的路径用8进行标记 二. 迷宫问题求解 1.使用队列进行深度优先搜索 查找路径思路： 将起点位置存入队列中； 每次访问队头元素，让队头元素出队，标
AVL树插入删除详解
m0_51765966的博客
05-17 1611
AVL树1.AVL树的定义及其特点(1)定义（2）特点2.ALV树的模拟实现（1）AVL树的数据结构（2）AVL树的插入操作左旋右旋先左旋再右旋先右旋再左旋 1.AVL树的定义及其特点 (1)定义 一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： 它的左右子树都是AVL树； 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)； （2）特点 2.ALV树的模拟实现 （1）AVL树的数据结构 （2）AVL树的插入操作 左旋 右旋 先左旋再右旋 先右旋再左旋 ...
图初识
m0_51765966的博客
10-31 974
图一.图的基本概念1.什么是图?2.顶点和边3.有向图和无向图4.有向完全图和无向完全图5.邻接顶点6.顶点的度7.路径8.权9.路径长度10.简单路径和回路11.子图12.连通图和强连通图13.生成树二.图的存储结构1.邻接矩阵法代码实现：2.邻接表法代码实现三.图的两种遍历方式1.深度优先2.广度优先 一.图的基本概念 1.什么是图? 图是由顶点集合和顶点之间的关系构成的一种数据结构. 在现实世界中应用极其广泛，比如人与人之间的朋友关系，地图中各个地点之间的关系 简单的图示例： 2.顶点和边 图的节点
排序算法详解及代码实现
m0_51765966的博客
02-24 436
排序算法1.直接插入排序2.希尔排序3.直接选择排序4.堆排序5.冒泡排序6.快速排序7.归并排序8.计数排序9.桶排序10.基数排序各种排序算法时间复杂度和稳定性比较 此处所有算法都是递增排序 1.直接插入排序 (1)思想： 假设第一个数据有序， 插入过程: 如果要插入的数据大于等于有序序列的最后一位，将要插入的数据放在最后一位的后面，否则从有序序列的最后一个位置开始向前遍历，找到第一个小于待插入数据的位置，将它后面的数据全部往后移一位，再将要插入的数据放到已找到位置的下一个位置。 (2)代码 //第一种
并查集初识
m0_51765966的博客
11-07 322
数据结构之并查集1.并查集的基本认识2.并查集代码实现3.使用并查集解决的典型力扣题1) .剑指 Offer II 116. 省份数量2) .等式方程的可满足性 1.并查集的基本认识 一种树形的数据结构，常用来处理不相交集合的查询和合并问题。 在并查集中，将元素分为若干个集合，每个集合相互独立，同一集合中的元素都有一个相同的祖先节点 举个例子： 有6个人分别用A、B、C、D、E、F表示， ABC是朋友，DF是朋友，那么这六个人中就有三个小团体，也就是三个集合， 在偶然的情况下，B和E成为了朋友，B把E介绍给
c语言实现合并顺序表
最新发布
12-08
以下是C语言实现合并顺序表的代码和注释说明： ```c #include #include #include #define MAX_SIZE 10 // 定义顺序表的最大长度 // 定义顺序表结构体 typedef struct { int data[MAX_SIZE]; // 存储数据的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值