【数据结构】— 线性表之「顺序表」的实现

已于 2022-07-29 00:48:33 修改
阅读量1.1k 收藏 8
点赞数 15
分类专栏： 【数据结构初阶】 文章标签： 数据结构 c语言
于 2022-07-28 23:18:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63938813/article/details/126029453
版权

꧁   各位大佬们好！很荣幸能够得到您的访问，让我们一起在编程道路上任重道远！꧂

☙ 博客专栏：【数据结构初阶】❧

⛅ 本篇内容简介：数据结构初阶中的线性表之顺序表的实现！

⭐ 了解作者：励志成为一名编程大牛的学子，目前正在升大二的编程小白。

✍励志术语：编程道路的乏味，让我们一起学习变得有趣！

✂   正文开始

文章目录

𝅬 什么是线性表？

 𝅫 顺序表

𝅪 概念及结构

𝅬 静态顺序表

𝅬 动态顺序表

 𝅫 动态顺序表的接口实现

𝅪 顺序表初始化

𝅪 顺序表销毁

𝅪 顺序表扩容

𝅪 顺序表打印

𝅪 顺序表头插

𝅪 顺序表头删

 𝅪 顺序表尾插

 𝅪 顺序表尾删

𝅪 顺序表在pos位置插入x

 𝅪 顺序表查找

𝅪 顺序表删除pos位置的值

𝅪 顺序表修改

𝅫 动态顺序表的接口改进

𝅪 顺序表头删

𝅪 顺序表头插

𝅪 顺序表尾插

𝅪 顺序表尾删

𝅫 程序文件中源代码

𝅪 SeqList.h

𝅪 SeqList.c

𝅪 test.c

𝅫 结束语

𝅬 什么是线性表？

线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一个在实际中广泛使用的数据结构，常见的线性表有：顺序表，链表，队列，字符串等等，今天我们实现的就是其中最简单的顺序表。

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理结构上存储时，通常以数组和链式结构的形式存储。

我们来用图解一下什么是顺序表，什么是链表：

c1ea45af31e14bebad0530b803616438.png

 2bb233a96ff1430ca8fb54b89c6e8de9.png

 𝅫 顺序表

𝅪 概念及结构

顺序表是用一段物理地址连续的存放存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

顺序表一般可分为：

𝅬 静态顺序表

使用定长数组存储元素（代码表示）：

#pragma once 

#include<stdio.h>

//静态顺序表

#define N 7

typedef int SLDataType;   //顺序表中的内容可能是其他类型的数据 

typedef struct SeqList
{
	SLDataType arr[N];//定长数组
	size_t size;//有效数据的个数
}SeqList;

图形演示静态顺序表结构：

b7835254e3b648abb199871c07fb094f.png

𝅬 动态顺序表

使用动态开辟的数组存储（代码表示）：

typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* arr;//指向动态开辟的数组
	size_t size;//有效数据个数
	int capacity;//容量空间的大小
}SeqList;

图形演示动态顺序表结构：

541631a01a6d416882b98376570c4fca.png

 𝅫 动态顺序表的接口实现

静态顺序表只适用于确定了知道存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以实现中基本都是使用动态顺序表，根据需要动态分配空间大小，所以下面我们来实现操作顺序表的接口——（增删查改）！

𝅪 顺序表初始化

void SeqListInit(SeqList* ps);

想一想我们为什么要用指针来接受呢？因为如果不传递地址，只传递值，实参只是形参的一份临时拷贝。，所以要改变顺序表中的内容，只能传递地址。

//顺序表的初始化
void SeqListInit(SeqList* ps)
{
	assert(ps);//断言 预防空指针
	ps->arr = NULL;
	ps->capicity = ps->size = 0;
}

我们调式测试一下看，是否初始化的内容：

8c5b1f9528714c5c93ab1413e980d6c2.png

 说明初始化函数将指针，数值，容量全部初始化了！！！

𝅪 顺序表销毁

void SeqListDestory(SeqList* ps);
//顺序表的销毁
void SeqListDestory(SeqList* ps)
{
	assert(ps->arr);
	free(ps);
	ps->arr = NULL;
	ps->capicity = ps->size = 0;
}

因为是动态开辟的内存空间，所以一定要结束程序之前销毁，否则会造成内存泄漏！

𝅪 顺序表扩容

void CheckCapacity(SeqList* ps);

扩容的思路（当容量==有效数据）：

先给定一个初始化的容量，如果有容量，直接扩容到两倍，将这个容量给一个新的容量表达式。

为什么要扩容到两倍？

一次扩多了，存在空间浪费，扩少了，会造成频繁扩容，效率损失。

//顺序表的扩容
void CheckCapacity(SeqList* ps)
{
	assert(ps);
	if (ps->capacity == ps->size)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			//扩容失败
			ferror("realloc fail");
			return;
		}
		else
		{
			//扩容成功
			ps->arr = tmp;
			ps->capacity = newcapacity;
		}
	}
}

𝅪 顺序表打印

void SeqListPrint(SeqList* ps);
//顺序表的打印
void SeqListPrint(SeqList* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");//换行
}

𝅪 顺序表头插

void SeqListPushFront(SeqList* ps, SLDataType x);

实现思路：

先判断是否需要扩容，再将后面的数据从后往前挪动，最后将下标为0的位置赋值为x。

图解：

8f0bd5ed9c7d4518b975a33e83288ed5.png

 代码实现：

//顺序表的头插
void SeqListPushFront(SeqList* ps, SLDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	int end = ps->size;
	while (end >= 0)
	{
		ps->arr[end] = ps->arr[end - 1];
		end--;
	}
	ps->arr[0] = x;
	ps->size++;
}

运行结果测试头插跟打印函数功能实现！！！

1961e13d504a45e696b07fa263c05a43.png

𝅪 顺序表头删

void SeqListPopFront(SeqList* ps);

实现思路：

不需要free掉内存，也不需要在开辟一块新的地址。将下标为1的数据往前覆盖即可。

图解：

f968dafb06c047e78724f26c1f60db22.png

 代码实现：

//顺序表的头删
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	//判断size是否>0
	assert(ps->size > 0);
	int begin = 1;
	while (begin < ps->size)
	{
		ps->arr[begin - 1] = ps->arr[begin];
		begin++;
	}
	ps->size--;
}

运行结果测试（成功头删）：

e51462454df347e6a911ecaecfb295b9.png

 𝅪 顺序表尾插

void SeqListPushBack(SeqList* ps,SLDataType x);

实现思路：

先检查是否需要增容，再在下标为size的位置插入数据，size++。

代码实现：

//顺序表的尾插
void SeqListPushBack(SeqList* ps,SLDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	ps->arr[ps->size] = x;
	ps->size++;
}

运行结果测试（成功尾插）：

e3e658f214be48fd97f8cbf0d27f5853.png

 𝅪 顺序表尾删

void SeqListPopBack(SeqList* ps);

实现思路：

先判断ps->size是否大于0，再size--就删除了。

代码实现：

//顺序表的尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	ps->size--;
}

运行结果测试（成功尾删）：

eed280da05d94d478f406be3d6f06f41.png

𝅪 顺序表在pos位置插入x

void SeqListInsert(SeqList* ps, size_t pos, SLDataType x);

说明一下：为什么pos位置的类型是size_t (无符号的整型)？

因为在库里面（string）中它是无符号的实现方式。

实现思路：

因为是在pos位置前面插入的，所以需要后挪动数据，我们需要定义一个尾部的下标，如果我们定义end=size-1的话，在比较pos大小时，会发生整型提升，所以我们把尾部下标定义在size的位置。（定义size-1位置强制类型转化pos就可以了）。

图解：

d66f20540c3841cf832d2f50afbfd40b.png

 代码实现：

//顺序表在pos的位置插入x
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	int end = ps->size;
	while (end > pos)
	{
		ps->arr[end] = ps->arr[end - 1];
		end--;
	}
	ps->arr[pos] = x;
	ps->size++;
}

运行结果测试 —— （成功插入）：

155e882b010a43b0be2682757a744113.png

 𝅪 顺序表查找

int SeqListFind(SeqList* ps, SLDataType x);

实现思路：

在顺序表中查找某个数，找到了，返回下标，找不到返回-1。

代码实现：

//顺序表的查找
int SeqListFind(SeqList* ps, SLDataType x)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

运行结果测试 —— 一般查找配合其他功能函数一起使用，比如我们测试配合在pos位置插入功能实现：

c68f34f0f6e8490ba7d27d95bfb62fd8.png

𝅪 顺序表删除pos位置的值

void SeqListErase(SeqList* ps, size_t pos);

实现思路：

定义一个begin下标在pos+1的位置，从前往后覆盖pos的数据。

图解：

a0bdff83007c4e2b8de033769e34fb39.png

代码实现：

//顺序表删除pos位置的值
void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps);
	//判断size是否大于0
	assert(ps->size > 0);
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->arr[begin - 1] = ps->arr[begin];
		begin++;
	}
	ps->size--;
}

测试删除pos下标的值，这里我们配合SeqListFind函数功能使用：

d6f1be1e0e1c441d94c22e5d3e942dff.png

𝅪 顺序表修改

void SeqListModify(SeqList* ps, size_t pos,SLDataType x);

实现思路：

直接将pos下标的值修改成x，就行。

代码实现：

//顺序表修改
void SeqListModify(SeqList* ps, size_t pos, SLDataType x)
{
	assert(ps);
	//判断pos是否 < ps->size
	assert(pos < ps->size);
	ps->arr[pos] = x;
}

测试修改功能 —— 搭配SeqListFind函数使用（成功修改）：

2f7fba04ce7140a2bb4d069b5e4fa4d0.png

𝅫 动态顺序表的接口改进

𝅪 顺序表头删

//顺序表的头删改进
void SeqListPopFront(SeqList* ps)
{
	//assert(ps);
	判断size是否>0
	//assert(ps->size > 0);
	//int begin = 1;
	//while (begin < ps->size)
	//{
	//	ps->arr[begin - 1] = ps->arr[begin];
	//	begin++;
	//}
	//ps->size--;

	//头删改进
	SeqListErase(ps, 0);
}

𝅪 顺序表头插

//顺序表的头插改进
void SeqListPushFront(SeqList* ps, SLDataType x)
{
	/*assert(ps);
	CheckCapacity(ps);
	int end = ps->size;
	while (end >= 0)
	{
		ps->arr[end] = ps->arr[end - 1];
		end--;
	}
	ps->arr[0] = x;
	ps->size++;*/


	//头插改进
	SeqListInsert(ps, 0, x);
}

𝅪 顺序表尾插

//顺序表的尾插
void SeqListPushBack(SeqList* ps,SLDataType x)
{
	/*assert(ps);
	CheckCapacity(ps);
	ps->arr[ps->size] = x;
	ps->size++;*/

	//尾插改进
	SeqListInsert(ps, ps->size, x);
}

𝅪 顺序表尾删

//顺序表的尾删
void SeqListPopBack(SeqList* ps)
{
	/*assert(ps);
	assert(ps->size > 0);
	ps->size--;*/

	//尾删改进
	SeqListErase(ps, ps->size - 1);
}

𝅫 程序文件中源代码

𝅪 SeqList.h

用于存放顺序表，函数功能的定义，头文件的引用等。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#pragma once 

//静态顺序表
//
//#define N 10
//
//typedef int SLDataType;   //顺序表中的内容可能是其他类型的数据 
//
//typedef struct SeqList
//{
//	SLDataType arr[N];//定长数组
//	size_t size;//有效数据的个数
//}SeqList;


//顺序表的动态存储
typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* arr;//指向动态开辟的数组
	size_t size;//有效数据个数
	int capacity;//容量空间的大小
}SeqList;


//顺序表的初始化
void SeqListInit(SeqList* ps);

//顺序表的销毁
void SeqListDestory(SeqList* ps);

//顺序表的扩容
void CheckCapacity(SeqList* ps);

//顺序表的打印
void SeqListPrint(SeqList* ps);

//顺序表的头插
void SeqListPushFront(SeqList* ps, SLDataType x);

//顺序表的头删
void SeqListPopFront(SeqList* ps);

//顺序表的尾插
void SeqListPushBack(SeqList* ps,SLDataType x);

//顺序表的尾删
void SeqListPopBack(SeqList* ps);

//顺序表的查找
int SeqListFind(SeqList* ps, SLDataType x);

//顺序表在pos的位置插入x
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x);

//顺序表删除pos位置的值
void SeqListErase(SeqList* ps, size_t pos);

//顺序表修改
void SeqListModify(SeqList* ps, size_t pos,SLDataType x);

𝅪 SeqList.c

用于实现 顺序表 中函数功能的定义。

#include"SeqList.h"

//用于定义顺序表接口函数

//顺序表的初始化
void SeqListInit(SeqList* ps)
{
	assert(ps);//断言 预防空指针
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

//顺序表的销毁
void SeqListDestory(SeqList* ps)
{
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

//顺序表的扩容
void CheckCapacity(SeqList* ps)
{
	assert(ps);
	if (ps->capacity == ps->size)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			//扩容失败
			ferror("realloc fail");
			return;
		}
		else
		{
			//扩容成功
			ps->arr = tmp;
			ps->capacity = newcapacity;
		}
	}
}

//顺序表的打印
void SeqListPrint(SeqList* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");//换行
}

//顺序表的头插改进
void SeqListPushFront(SeqList* ps, SLDataType x)
{
	/*assert(ps);
	CheckCapacity(ps);
	int end = ps->size;
	while (end >= 0)
	{
		ps->arr[end] = ps->arr[end - 1];
		end--;
	}
	ps->arr[0] = x;
	ps->size++;*/


	//头插改进
	SeqListInsert(ps, 0, x);
}

//顺序表的头删改进
void SeqListPopFront(SeqList* ps)
{
	//assert(ps);
	判断size是否>0
	//assert(ps->size > 0);
	//int begin = 1;
	//while (begin < ps->size)
	//{
	//	ps->arr[begin - 1] = ps->arr[begin];
	//	begin++;
	//}
	//ps->size--;

	//头删改进
	SeqListErase(ps, 0);
}

//顺序表的尾插
void SeqListPushBack(SeqList* ps,SLDataType x)
{
	/*assert(ps);
	CheckCapacity(ps);
	ps->arr[ps->size] = x;
	ps->size++;*/

	//尾插改进
	SeqListInsert(ps, ps->size, x);
}

//顺序表的尾删
void SeqListPopBack(SeqList* ps)
{
	/*assert(ps);
	assert(ps->size > 0);
	ps->size--;*/

	//尾删改进
	SeqListErase(ps, ps->size - 1);
}

//顺序表的查找
int SeqListFind(SeqList* ps, SLDataType x)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}


//顺序表在pos的位置插入x
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x)
{
	assert(ps);
	assert(pos < ps->size);
	CheckCapacity(ps);
	int end = ps->size;
	while (end > pos)
	{
		ps->arr[end] = ps->arr[end - 1];
		end--;
	}
	ps->arr[pos] = x;
	ps->size++;
}

//顺序表删除pos位置的值
void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps);
	assert(pos < ps->size);
	//判断size是否大于0
	assert(ps->size > 0);
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->arr[begin - 1] = ps->arr[begin];
		begin++;
	}
	ps->size--;
}

//顺序表修改
void SeqListModify(SeqList* ps, size_t pos, SLDataType x)
{
	assert(ps);
	//判断pos是否 < ps->size
	assert(pos < ps->size);
	ps->arr[pos] = x;
}

𝅪 test.c

用于存放顺序表功能函数的测试，可以写成菜单形式，但是我这里就不写了，只写成测试形式。

#include"SeqList.h"

//用于测试顺序表的函数功能
void test1()
{
	//测试初始化
	SeqList s1;
	SeqListInit(&s1);

	//测试头插
	SeqListPushFront(&s1, 1);
	SeqListPushFront(&s1, 2);
	SeqListPushFront(&s1, 3);
	SeqListPushFront(&s1, 4);

	SeqListPrint(&s1);//打印一下

	//测试头删
	SeqListPopFront(&s1);
	SeqListPopFront(&s1);

	SeqListPrint(&s1);

	//测试尾插
	SeqListPushBack(&s1, 20);
	SeqListPushBack(&s1, 30);
	SeqListPushBack(&s1, 40);

	SeqListPrint(&s1);

	//测试尾删
	SeqListPopBack(&s1);
	SeqListPrint(&s1);

	//测试pos位置插入

	SeqListInsert(&s1, 3, 60);
	SeqListPrint(&s1);

	//测试查找
	SeqListInsert(&s1, SeqListFind(&s1,60), 88);
	SeqListPrint(&s1);

	//测试删除pos的值
	SeqListErase(&s1, SeqListFind(&s1, 88));
	SeqListPrint(&s1);

	//测试修改
	SeqListModify(&s1, SeqListFind(&s1, 1), 100);
	SeqListPrint(&s1);

	SeqListDestory(&s1);
}

int main()
{
	test1();
	return 0;
}

𝅫 结束语

数据结构之线性表中的顺序表就已经改进好了，希望这篇8000多字的博客能够帮助到你更加深刻的理解顺序表，以及顺序表的实现，创作不易，给博客来个三连叭！！！

6eb2d81cdcec4abdba28a18df9b0ab1c.jpeg

甘宸しぐれ
关注
  • 15
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
专栏目录
数据结构之线性表的顺序表示和实现
05-28
线性表的顺序表示和实现，博客链接： http://blog.csdn.net/u013071074/article/details/27336291
数据结构线性表-顺序表（c++、java）.pdf
11-12
在线性表中，元素之间存在一对一的逻辑关系，而顺序表则是将这些逻辑上相邻的元素在内存中也保持相邻，通常通过数组实现。顺序表有静态分配和动态分配两种实现方式。 静态分配的顺序表使用一个预先分配好的定长数组...
线性表详细讲述（带图）
m0_64413166的博客
11-18 2816
线性表，有手就可以学废
数据结构基础和算法图解(2)——线性表
zyw2002的博客
05-10 783
文章目录2. 线性表2.1 线性表的逻辑结构2.1.1 例题2.2 线性表的操作2.2.1 合并集合2.2.2 过滤集合中的重复元素2.2.3合并有序表2.3 顺序表2.3.1线性表的顺序存储结构2.3.1.1 顺序表初始化2.3.2 顺序表的查找2.3.1.3 例题2.3.2 顺序表的插入2.3.2.1例题2.3.3 顺序表的删除2.3.3.1 例题2.3 单链表2.3.1 生成链表2.3.2 获取元素2.3.3 单链表存储结构改进2.3.4 例题2.3.5 单链表的插入2.3.5.1 例题2.3.6 单
【数据结构——顺序表的实现】
m0_56069910的博客
01-21 1193
顺序表的具体实现
【数据结构】顺序表的实现
学了就忘是正常现象
08-01 1073
【数据结构】顺序表的实现及数组相关oj题
【数据结构】顺序表的实现——超级无敌详细
qq_59702185的博客
08-07 1997
在当我们每想插入一个数据的时候，我们都要对顺序表进行判断，容量 capacity 是否和 size 相等，如果相等的话，那么，顺序表的空间就不够我们进行插入数据了。当然我们不能需要插入一个数据就开辟一个数据的大小，这样的话，付出的代价很大，我们可以每次增容 2 倍的capacity大小的容量，或者4倍，2倍是比较好的了。在我们想把顺表表最后一个数据删除时，不能直接赋为0，第一，我们不知道SLDataType到底是什么数据类型，第二，顺序表的最后一个数据有可能就是0，没有意义。遍历一遍顺序表，打印顺序表。..
数据结构学习--线性表及其应用--顺序表
06-25
在众多数据结构当中，线性表是最简单、也是最...本实验相对比较简单，通过本实验，对顺序表基本操作及 其组合应用的演练，加深对线性表顺序存储方法及其基本操作的理解，为以后进一步学习更 复杂的数据结构打下基础。
数据结构线性表(顺序表).ppt
07-11
线性表是数据结构中最基础且最常用的结构之一，它由n（n≥0）个相同特性的数据元素组成的一个有限序列。在这个序列中，第一个元素没有直接前驱，最后一个元素没有直接后继，其余每个元素都有且只有一个直接前驱和...
数据结构 线性表的顺序存储-顺序表 自用
07-05
数据结构 线性表的顺序存储-顺序表 自用
数据结构顺序表的算法实现
07-06
数据结构中顺序表的C语言程序简单源代码，数据结构顺序表的算法实现
线性表顺序表示及实现源码
11-11
线性表的顺序表示和实现源码。 Blog: http://blog.csdn.net/algorithm_only
【数据结构】线性表的顺序存储结构及实现——C语言版
热门推荐
Anya-.-的博客
10-03 2万+
线性表的顺序存储结构（顺序表）及实现——C语言版
线性表的顺序结构实现
qq_43224368的博客
04-24 1107
线性表：最基础的数据结构，特点是一连一。 实现方式有顺序结构和链式结构，以下是顺序结构实现的代码。 /* 线性的顺序结构实现 函数：打印表；插入元素；删除元素。 */ #include <stdio.h> #include <Windows.h> #define maxNum 100 //线性表的顺序结构 typedef struct spList { int da...
线性表的顺序存储结构的实现（超详解版）简单易懂
H_define的博客
03-04 2244
线性表的顺序存储结构的实现 定义顺序表如下： typedef struct { ElemType *elem; int length; }SqList; 基本操作函数如下： void init(SqList &L)//构造一个空的顺序表L bool empty(SqList L)//判断线性表是否为空 int get(SqList L,int i)//在线性表L中求序号为i的元素，该...
01线性表顺序存储_List
AKK188888881的博客
10-05 492
#include<stdio.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 20 /* 存储空间初始分配量 */ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int ElemType; /* ElemType类型根据实际情况而定，这里假设为int */ Stat
educoder数据结构与算法 线性表 第1关：实现一个顺序存储的线性表
兴趣使然的编程菜鸟
01-02 2060
注意：本关必读中提及的其他操作已经由平台实现，你在实现本关任务的三个操作函数时，在函数体内可调用其他操作。本关的测试文件是 step1/Main.cpp ，负责对实现的代码进行测试。返回被删除的数据元素的值。三个操作函数，以实现线性表中数据的插入、删除与查找等功能。所指向的用于存储线性表数据元素的存储空间。三个操作函数，以实现线性表中数据的插入、删除与查找等功能。个数据元素的顺序存储的线性表，并将其初始状态设置为。的数据元素，返回该数据元素的编号。获取线性表当前长度：获取并返回线性表的当前长度。
数据结构线性表中的顺序表实现
rainturbons的博客
04-09 222
#include<iostream> #include<malloc.h> using namespace std; typedef int ElemType; #define InitSize 100 #define LISTINCREMENT 10 typedef struct{ ElemType *data; int length;//线性表的长度 ...
数据结构学习之线性表的顺序实现（python 实现)
zhangwei15hh的博客
12-10 2613
线性表1.抽象数据类型表示（ADT）类型名称：线性表 数据对象集：线性表是n(>=0)个元素构成的有序序列（a1,a2,….,an） 操作集：2.线性表的顺序实现 表示方法： 其中100可以自己规定，last代表线性表的长度 # 线性表定义 class Lnode(object): def __init__(self,last): self.data = [None
数据结构的线性表-顺序表插入、删除、查找实现功能
最新发布
04-17
线性表是一种常见的数据结构，顺序表是线性表的一种实现方式。顺序表使用数组来存储数据，具有随机访问的特点。下面是顺序表的插入、删除和查找的实现功能： 1. 插入操作： - 在指定位置插入元素：首先判断插入...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

甘宸しぐれ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值