顺序存储的线性表的实现

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

顺序存储的线性表的实现

说明

  1. 参考资料
    • 传智播客扫地僧的数据结构教学视频
  2. 线性表基础知识
  3. 该实现的说明
    • C语言实现
    • 实现算法和数据的分离

实现

  1. seq_list.h

    #ifndef _SEQ_LIST_H_
#define _SEQ_LIST_H_

#ifdef __cplusplus
extern "C"{
#endif


typedef void SEQ_LIST;			// 顺序线性表
typedef void SEQ_LIST_NODE;		// 线性表的节点类型

/* 创建顺序线性表，返回顺序线性表的地址 */
SEQ_LIST* SeqList_Create(int capacity);

/* 销毁顺序线性表的空间 */
void SeqList_Destroy(SEQ_LIST* list);

/* 清空顺序线性表的元素 */
void SeqList_Clear(SEQ_LIST* list);

/* 获取顺序线性表中元素的个数 */
int SeqList_Length(SEQ_LIST* list);

/* 获取顺序线性表的最大容量 */
int SeqList_Capacity(SEQ_LIST* list);

/* 在下标为pos的位置插入元素 */
int SeqList_Insert(SEQ_LIST* list, SEQ_LIST_NODE* node, int pos);

/* 获取顺序线性表中下标为pos的元素的地址 */
SEQ_LIST_NODE* SeqList_Get(SEQ_LIST* list, int pos);

/* 删除顺序线性表中下标为pos的节点 */
SEQ_LIST_NODE* SeqList_Delete(SEQ_LIST* list, int pos);

#ifdef __cplusplus
}
#endif

#endif

  2. seq_list.c

    #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "seq_list.h"

/* 用来实现顺序线性表的一个结构体 */
typedef struct TAG_SEQ_LIST
{
	unsigned int	length;			// 顺序线性表的元素个数
	unsigned int	capacity;		// 顺序线性表的容量
	SEQ_LIST_NODE**	node;			// 指向线性表节点的指针
}TAG_SEQ_LIST;


/* 创建顺序线性表，返回顺序线性表的地址 */
SEQ_LIST* SeqList_Create(int capacity)
{
	TAG_SEQ_LIST* seq_list = NULL;		// 线性表指针

	/* 检查输入参数 */
	if (capacity <= 0)
	{
		printf("func SeqList_Create() err: capacity < 0\n");
		return NULL;
	}

	/* 申请结构体空间 */
	seq_list = (TAG_SEQ_LIST*)malloc(sizeof(TAG_SEQ_LIST));
	if (seq_list == NULL)
	{
		printf("func SeqList_Create() err: seq_list == NULL\n");
		return NULL;
	}
	memset(seq_list, 0, sizeof(TAG_SEQ_LIST));		// 给申请的空间赋初值

	/* 根据参数申请线性表空间大小 */
	seq_list->node = (SEQ_LIST_NODE**)malloc(sizeof(SEQ_LIST_NODE*) * capacity);
	if(seq_list->node == NULL)
	{
		printf("func SeqList_Create() err: seq_list->node == NULL\n");
		free(seq_list);
		return NULL;
	}
	memset(seq_list->node, 0, sizeof(SEQ_LIST_NODE*) * capacity);

	/* 根据参数给结构赋值 */
	seq_list->capacity = capacity;
	seq_list->length = 0;
	
	return seq_list;
}


/* 销毁顺序线性表的空间 */
void SeqList_Destroy(SEQ_LIST* list)
{
	TAG_SEQ_LIST* seq_list = NULL;

	/* 检查输入参数 */
	if (list == NULL)
	{
		printf("func SeqList_Destroy() err: list == NULL\n");
		return;
	}

	seq_list = (TAG_SEQ_LIST*)list;			// 将传来的线性表地址强制类型转化为结构体地址

	if(seq_list->node != NULL)
	{
		free(seq_list->node);
		seq_list->node = NULL;
	}

	free(seq_list);
	seq_list = NULL;

	return;
}


/* 清空顺序线性表的元素 */
void SeqList_Clear(SEQ_LIST* list)
{
	TAG_SEQ_LIST* seq_list = NULL;
	
	/* 检查输入参数 */
	if (list == NULL)
	{
		printf("func SeqList_Clear() err: list == NULL\n");
		return ;
	}

	seq_list = (TAG_SEQ_LIST*)list;			// 将传来的线性表地址强制类型转化为结构体地址

	seq_list->length = 0;
	return;
}


/* 获取顺序线性表中元素的个数 */
int SeqList_Length(SEQ_LIST* list)
{
	TAG_SEQ_LIST* seq_list = NULL;
	
	/* 检查输入参数 */
	if (list == NULL)
	{
		printf("func SeqList_Length() err: list == NULL\n");
		return -1;
	}

	seq_list = (TAG_SEQ_LIST*)list;			// 将传来的线性表地址强制类型转化为结构体地址

	return seq_list->length;
}


/* 获取顺序线性表的最大容量 */
int SeqList_Capacity(SEQ_LIST* list)
{
	TAG_SEQ_LIST* seq_list = NULL;
	
	/* 检查输入参数 */
	if (list == NULL)
	{
		printf("func SeqList_Capacity() err: list == NULL\n");
		return -1;
	}

	seq_list = (TAG_SEQ_LIST*)list;			// 将传来的线性表地址强制类型转化为结构体地址
	return seq_list->capacity;
}


/* 在下标为pos的位置插入元素 */
int SeqList_Insert(SEQ_LIST* list, SEQ_LIST_NODE* node, int pos)
{
	TAG_SEQ_LIST* seq_list = NULL;
	int i = 0;
	int ret = 0;		// 错误码
	
	/* 检查输入参数 */
	if (list == NULL || node == NULL || pos < 0)
	{
		ret = -1;
		printf("func SeqList_Insert() err: list == NULL || node == NULL || pos < 0\n");
		return ret;
	}

	seq_list = (TAG_SEQ_LIST*)list;			// 将传来的线性表地址强制类型转化为结构体地址

	/* 判满 */
	if (seq_list->length >= seq_list->capacity)
	{
		ret = -2;
		printf("func SeqList_Insert() err: seq_list->length >= seq_list->capacity\n");
		return ret;
	}

	/* 容错处理：当插入位置大于线性表的length时，不报错而是进行修正，采用尾插法 */
	if (pos > seq_list->length)
	{
		pos = seq_list->length;
	}

	/* 插入点pos位置后面的元素后移 */
	for (i = seq_list->length; i > pos; --i)
	{
		seq_list->node[i] = seq_list->node[i - 1];
	}
	
	/* 插入元素 */
	seq_list->node[pos] = node;
	seq_list->length++;

	return pos;			// 返回实际插入位置
}


/* 获取顺序线性表中下标为pos的元素的地址 */
SEQ_LIST_NODE* SeqList_Get(SEQ_LIST* list, int pos)
{
	TAG_SEQ_LIST* seq_list = NULL;
	
	/* 检查输入参数 */
	if (list == NULL || pos < 0)
	{
		printf("func SeqList_Get() err: list == NULL || pos < 0\n");
		return NULL;
	}

	seq_list = (TAG_SEQ_LIST*)list;			// 将传来的线性表地址强制类型转化为结构体地址
	
	/* 判断位置pos的合法性 */
	if (pos >= seq_list->length)
	{
		printf("func SeqList_Get() err: pos >= seq_list->length\n");
		return NULL;
	}

	return seq_list->node[pos];
}


/* 删除顺序线性表中下标为pos的节点 */
SEQ_LIST_NODE* SeqList_Delete(SEQ_LIST* list, int pos)
{
	TAG_SEQ_LIST* seq_list = NULL;
	SEQ_LIST_NODE* deleted_node = NULL;
	int i = 0;
	
	/* 检查输入参数 */
	if (list == NULL || pos < 0)
	{
		printf("func SeqList_Delete() err: list == NULL || pos < 0\n");
		return NULL;
	}

	seq_list = (TAG_SEQ_LIST*)list;			// 将传来的线性表地址强制类型转化为结构体地址
	
	/* 判空 */
	if (seq_list->length <= 0)
	{
		printf("func SeqList_Delete() err: seq_list->length <= 0\n");
		return NULL;
	}

	/* 判断pos位置的合法性 */
	if (pos >= seq_list->length)
	{
		printf("func SeqList_Delete() err: pos >= seq_list->length\n");
		return NULL;
	}

	/* 缓存pos位置元素 */
	deleted_node = seq_list->node[pos];

	/* pos位置后面的元素前移 */
	for (i = pos + 1; i < seq_list->length; ++i)
	{
		seq_list->node[i - 1] = seq_list->node[i];
	}
	seq_list->length--;

	return deleted_node;
}

  3. test.c

    #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "seq_list.h"

/* 老师结构体 */
typedef struct TEACHER
{
	int age;
	char name[64];
}TEACHER;

/* 打印老师结构体信息函数 */
void PrintTeacher(TEACHER *t)
{
	printf("name = %s, age = %d",t->name, t->age);
}

int main(void)
{
	SEQ_LIST* teacher_list = NULL, *int_list = NULL;		// 线性表实体
	int teacher_list_capacity = 0, int_list_capacity = 0;
	int teacher_list_length = 0, int_list_length = 0;
	int teacher_list_insert_pos = 0, int_list_insert_pos = 0;
	int i = 0;

	int a = 4, b = 23, c = 45, d = 100;
	
	TEACHER t1, t2, t3, *t;
	t1.age = 31;
	strcpy(t1.name,"张三");
	t2.age = 32;
	strcpy(t2.name,"李四");
	t3.age = 33;
	strcpy(t3.name,"王五");

	/*********************** TEACHER类型的顺序线性表 *********************/
	teacher_list = SeqList_Create(10);
	if (teacher_list == NULL)
	{
		printf("func main() err: teacher_list == NULL\n");
		return -1;
	}

	teacher_list_insert_pos = SeqList_Insert(teacher_list, (SEQ_LIST_NODE*)(&t1), 0);		// 头插法插入元素（省略执行结果检查）
	teacher_list_insert_pos = SeqList_Insert(teacher_list, (SEQ_LIST_NODE*)(&t2), 0);		// 头插法插入元素
	teacher_list_insert_pos = SeqList_Insert(teacher_list, (SEQ_LIST_NODE*)(&t3), 0);		// 头插法插入元素
	
	/* 获取teacher线性表中容量 */
	teacher_list_capacity = SeqList_Capacity(teacher_list);					// 省略执行结果检查
	printf("teacher_list_capacity = %d\n",teacher_list_capacity);

	/* 获取teacher线性表中元素个数 */
	teacher_list_length = SeqList_Length(teacher_list);
	printf("teacher_list_length = %d\n",teacher_list_length);

	for (i = 0; i < teacher_list_length; i++)
	{
		t = SeqList_Get(teacher_list, 0);		// 获取元素（省略执行结果检查）
		printf("获取元素：");
		PrintTeacher(t);
		printf("\n");

		t = SeqList_Delete(teacher_list, 0);	// 删除元素（省略执行结果检查）
		printf("删除元素：");
		PrintTeacher(t);
		printf("\n");
	}

	SeqList_Destroy(teacher_list);				// 销毁线性表


	/*********************** int类型的顺序线性表 *********************/
	int_list = SeqList_Create(20);
	if (int_list == NULL)
	{
		printf("func main() err: int_list == NULL\n");
		return -1;
	}

	int_list_insert_pos = SeqList_Insert(int_list, (SEQ_LIST_NODE*)(&a), 0);	// 头插法
	int_list_insert_pos = SeqList_Insert(int_list, (SEQ_LIST_NODE*)(&b), 0);	// 头插法
	int_list_insert_pos = SeqList_Insert(int_list, (SEQ_LIST_NODE*)(&c), 0);	// 头插法
	int_list_insert_pos = SeqList_Insert(int_list, (SEQ_LIST_NODE*)(&d), 0);	// 头插法

	int_list_capacity = SeqList_Capacity(int_list);	//获取线性表容量
	printf("int_list_capacity = %d\n", int_list_capacity);
	int_list_length = SeqList_Length(int_list);		//获取线性表元素个数
	printf("int_list_length = %d\n", int_list_length);

	for (i = 0; i < int_list_length; ++i)
	{
		printf("获取元素：%d\n", *(int*)(SeqList_Get(int_list, 0)));
		printf("删除元素：%d\n", *(int*)(SeqList_Delete(int_list, 0)));
	}

	SeqList_Destroy(int_list);
	
	
	printf("Hello world!\n");

	return 0;
}
过客WZX
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python线性表顺序存储实现_数据结构（三）——基于顺序存储结构的线性表
weixin_29048775的博客
01-14 781
数据结构(三)——基于顺序存储结构的线性表一、基于顺序存储结构的线性表实现1、顺序存储的定义线性表的顺序存储结构是用一段地址连续的存储单元依次存储线性表中的数据元素。2、顺序存储结构的操作使用一维数组实现顺序存储结构。template class SeqList:public List{protected:T* m_array;//顺序存储空间int m_length;//当前线性表的长度};一维...
线性表的顺序存储方式
愣头小兵Blog
09-20 656
线性表的顺序存储方式比较简单，也很容易理解，不作过多说明，直接上代码实现，用的是C语言 #include #define MAXSIZE 100 #define OK 1 #define ERROR 0 typedef int ElemType; typedef struct //定义顺序表（线形表的顺序存储结构） { ElemTy
第1关：实现一个顺序存储的线性表
m0_62752579的博客
11-01 3581
注意：本关必读中提及的其他操作已经由平台实现，你在实现本关任务的三个操作函数时，在函数体内可调用其他操作。本关的测试文件是 step1/Main.cpp ，负责对实现的代码进行测试。返回被删除的数据元素的值。三个操作函数，以实现线性表中数据的插入、删除与查找等功能。所指向的用于存储线性表数据元素的存储空间。三个操作函数，以实现线性表中数据的插入、删除与查找等功能。个数据元素的顺序存储的线性表，并将其初始状态设置为。的数据元素，返回该数据元素的编号。获取线性表当前长度：获取并返回线性表的当前长度。
数据结构笔记-线性表
Don2100的博客
08-25 638
线性表 线性表结构 线性表定义 typedef int T; // 数据元素的数据类型。 struct SeqList{ T* data; // 数据元素的开始地址。 int len; // 当前长度。 int max; // 线性表的最大长度。 }; 线性表操作 SeqList* SL_Create(int maxlen){// 创建一个顺序表，与SqLst_Free()配对。 S...
数据结构：线性表（顺序表的实现）
qq_59325159的博客
03-02 509
线性表—动态顺序表的代码实现
线性表 :: 顺序存储结构的实现
weixin_53202576的博客
09-25 1542
使用C语言基于数组实现线性表的顺序存储结构。
顺序存储的线性表
qq_43717119的博客
11-28 3338
任务描述 本关任务：实现 step1/Seqlist.cpp 中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数，以实现线性表中数据的插入、删除与查找等功能。 相关知识 线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用不同的存储策略。下面给出了一种基于顺序存储的线性表实现方案： 该方案将线性表存储在一片连续空间里，并通过data、len和max三个属性元素。组织成为一个结构： data: 给出线
线性表的顺序存储与实现
07-29
线性表是计算机科学中一种基础的数据结构，它是由n（n≥0）个相同...提供的文件"02-线性表的顺序存储与实现"很可能是关于如何在具体编程语言中实现这些操作的示例代码，可以作为学习和理解线性表顺序存储的参考资料。
顺序线性表的代码实现方法
08-30
* 空间浪费：顺序线性表需要预留一定的空间来存储元素，这可能会导致空间浪费。 结论 顺序线性表是一种基本的数据结构，它可以用于实现各种应用程序。通过了解顺序线性表的实现细节和优缺，我们可以更好地应用顺序...
C语言实现的顺序线性表
01-16
本篇文章将深入探讨如何使用C语言来实现顺序线性表，包括其基本操作，如创建、插入数据、获取数据、删除数据、获取存放的数据量、清空线性表以及销毁线性表。 顺序线性表是由一组具有相同类型元素构成的序列，这些...
顺序存储的线性表基本算法实现
07-04
构造一个空的顺序表InitList_Sq； 初始化一个顺序表，将顺序表所有元素置为0 SetList_Sq 建立顺序表，给表中各元素赋值SetList_Sq 销毁一个已存在的顺序表, 回收所分配的空间DestroyList_Sq 将已存在的顺序表重置为空表ClearList_Sq； 判断表是否为空ListEmpty_Sq； 求顺序表中当前元素个数ListLength_Sq； 返回给定元素e的前驱priorElem_Sq； 返回给定元素e的后继NextElem_Sq 查找某个给定元素e出现的第一个位置LocateElem_Sq 查找给定位置i的元素GetElem_Sq 在第i个位置前插入新元素ListInsert_Sq； 删除给定位置i的元素（位置删除）ListDelete_Sq 删除顺序表中所有值为给定值的元素（值删除）ListDeleteElem_Sq 输出顺序表的内容ListPrint_Sq； 合并两个顺序表，即将一个顺序表接在另一个顺序表之后Append_Sq
线性表的顺序存储 线性表的顺序存储
11-30
在C++中实现线性表的顺序存储，通常会定义一个结构体或类来封装数组和相关的操作。这个结构体或类通常包含以下几个部分： 1. **数据成员**：一个大小固定的数组，用于存储线性表的元素。例如，可以声明一个整型数组...
线性表顺序存储运算的算法实现
09-03
本话题将深入探讨线性表的顺序存储结构及其在C语言中的算法实现，包括线性表的输入输出、插入、删除以及长度和置空操作。 1. **线性表的顺序存储结构** 在顺序存储结构中，线性表的元素在内存中以数组的形式存储，...
线性表的顺序存储结构具体实现 代码实战 赛博图书馆搭建指南（使用C\C++语言）
最新发布
m0_56661338的博客
04-05 615
完整地实现了用顺序表存储元素，并且通过将数据类型改为字符串结构体来搭建一个“赛博图书馆”，实现了顺序表的打印、插入元素、删除元素、查询元素，配以图文详解
数据结构实现一个顺序储存的线性表
weixin_57011178的博客
09-23 3245
一.什么线性表 线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用不同的存储策略。下面给出了一种基于顺序存储的线性表实现方案： 该方案将线性表存储在一片连续空间里，并通过data、len和max三个属性元素。组织成为一个结构： data: 给出线性表存储空间的起始地址； max: 指明线性表存储空间最多可存储的数据元素个数； len: 当前线性表里的数据元素个数。 为了讨论简化，我们假设每个数据元素是一.
线性表的实现（顺序存储）
shi_xiao_xuan的博客
10-30 1064
线性表的实现1.结构体定义2.初始化(建立空的顺序表)3.查找（按元素查找）4.插入5.删除6.查找（按位置查找）7.测试完整代码 1.结构体定义 线性表存储结构： 首先 typedef int ElementType;//定义别名 #define MAXSIZE 100 //宏定义 //第一种 typedef struct LNode { ElementType Data[MAX...
基于顺序存储结构的线性表实现-数据结构C语言
kim的博客
04-04 1658
实验名称: 基于顺序存储结构的线性表实现 目录 一、实验目的 二、实验环境安装设置 三、实验任务 四、程序框架 五、程序完整代码 六、程序测试 一、实验目的 加深对线性表的概念、基本运算的理解； 熟练掌握线性表的逻辑结构与物理结构的关系； 物理结构采用顺序表,熟练掌握线性表的基本运算的实现。 二、实验环境安装设置 1. 启动DevCPP在E：建立工作区MyCpp，所有的程序源码都存放在该文件夹下。 三、实验任务 认真研读框架程序，根据提供的实验框架（框架可以直接运
【数据结构】线性表的顺序存储结构及实现——C语言版
热门推荐
Anya-.-的博客
10-03 2万+
线性表的顺序存储结构（顺序表）及实现——C语言版
树（C语言）
过客的博客
08-29 8690
文章目录树树的定义树的一些基本术语树的表示 树 树的定义 树（Tree）：n(n≥0)n(n \geq 0)n(n≥0)个结点构成的有限集合。当n=0时，称为空树。 对于任一棵非空树（n&gt;0n&gt;0n>0）,它具有以下性质： 树中有一个称为“根（Root）”的特殊结点，用r表示； 其余结点可分为m(m&gt;0)m(m&gt;0)m(m&g...
顺序与链式存储：线性表实现详解
本篇文档主要讨论了线性表的两种基本存储实现方式：顺序存储和链式存储。在数据结构课程设计中，学生需要实现这两种数据结构，包括它们的抽象数据类型(ADT)中的基本操作。以下是详细的解析： 1. **需求分析** - **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值