【数据结构】顺序表的增删查改(C语言实现)

已于 2022-11-11 21:27:06 修改
阅读量857 收藏 18
点赞数 23
分类专栏： 数据结构与算法 文章标签： 数据结构 c语言 算法
于 2022-10-05 21:49:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_67582098/article/details/127177415
版权

文章目录

一、线性表

线性表的定义：

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使

用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的,

线性表在物理上存储时，通常以数组和链式结构的形式存储。

二、顺序表

1.顺序表的定义

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存

储。在数组上完成数据的增删查改。
在这里插入图片描述

2.顺序表的分类

静态顺序表：使用定长数组存储元素。

#define N 100 //数组的最大长度
typedef int SLDataType; //重命名数据类型
struct SeqList
{
	SLDataType arr[N];    //使用定长数组来存储数据
	int size;            //存储数据的个数
}SL;

动态顺序表：使用动态开辟的数组存储。

typedef int SLDataType;//将数据类型重命名为SLDataType
typedef struct SeqList
{
	SLDataType* arr;      //存储空间的地址
	int size;             //存储数据的个数
	int capacity;         //存储空间的大小
}SL;                      //重定义为SL

三、动态顺序表的实现

1.结构的定义

typedef int SLDataType;//将数据类型重命名为SLDataType
typedef struct SeqList
{
	SLDataType* arr;      //存储空间的地址
	int size;             //存储数据的个数
	int capacity;         //存储空间的大小
}SL;                      //重定义为SL

我们将数据类型重命名为SLDataType，这样以后我们管理其他数据类型的时候只需要改一个地方即可。

相对于静态顺序表，动态顺序表多了一个参数capacity，用来记录顺序表当前的容量，当当前的数据个数size和顺序的容量capacity相等时，需要进行扩容。

2.顺序表的初始化

void SeqListInit(SL* psl)
{
	assert(psl);//断言：防止psl为空


	psl->arr = NULL;
	psl->size = psl->capacity = 0;
}

在初始化顺序表时，将数据的空间地址置为空，size和capacity置为0，在需要存放数据时再动态开辟空间即可，也可以在初始化时先动态开辟一块空间。

3.检查顺序表的容量

void CheckCapacity(SL* psl)
{
	//检查容量
	if (psl->size == psl->capacity)
	{
		//将realloc的返回值由一个临时变量保存，防止扩容失败后丢失原来的空间地址
		int newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;
		SLDataType* tmp = (int*)realloc(psl->arr, newCapacity * sizeof(SLDataType));
		if (tmp == NULL)//判空
		{
			perror("realloc fail");//打印错误信息
			return;
			//exit(-1);//退出程序
		}

		psl->arr = tmp;//开辟的空间地址赋给psl->arr
		psl->capacity = newCapacity;//新的空间大小
	}
}

当size和capacity相等时，表示数组已经放满了数据，这时就需要进行扩容，我们一般扩容到原来的2倍，

因为扩容多了容易造成空间浪费，扩容少了，会频繁扩容，效率损失，2倍比较合适，1.5倍也可以。我们在动态开辟时，用一个临时变量接收realloc的返回时，这样就可以防止在扩容失败的时候丢失原来的空间。

4.顺序表的销毁

void SeqListDestroy(SL* psl)
{
	assert(psl);//断言：防止psl为空

	/*if (psl->arr)
	{*/
		free(psl->arr); //释放(避免内存泄漏)
		psl->arr = NULL;//指针置空(避免野指针)
		psl->size = psl->capacity = 0;
	//}
}

销毁顺序表时，释放arr数组空间，把size和capzcity置为0 即可。

5.打印顺序表中的数据

void SeqListPrint(SL* psl)
{
	assert(psl);//断言：防止psl为空

	//遍历数组
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->arr[i]);
	}

	printf("\n");

}

遍历数组，一次打印即可。

6.在头部插入数据

void SeqListPushFront(SL* psl, SLDataType x)
{
	assert(psl);//断言：防止psl为空

	CheckCapacity(psl);//检查容量，空间不够时扩容

	//从后往前挪动数据
	int end = psl->size - 1;
	while (end >= 0)
	{
		psl->arr[end + 1] = psl->arr[end];
		end--;
	}

	psl->arr[0] = x;
	psl->size++;

	//调用Insert函数
	//SLInsert(psl, 0, x);
}

在头部插入数据时，需要所有数据从后往前依次挪到下一个位置。(注意是从后往前挪，否则数据会被覆盖)

7.在尾部插入数据

void SeqListPushBack(SL* psl, SLDataType x)
{
	assert(psl);//断言：防止psl为空

	CheckCapacity(psl);//检查容量，空间不够时扩容

	psl->arr[psl->size] = x;
	psl->size++;

	//调用Insert函数
	//SLInsert(psl, psl->size, x);
}

在尾部插入时，直接插入即可。

8.在pos位置插入数据

void SeqListInsert(SL* psl, size_t pos, SLDataType x)
{
	assert(psl);//断言：防止psl为空
	assert(pos <= psl->size);//不能在psl->size之后插入

	CheckCapacity(psl);//检查容量，空间不够时扩容

	//int end = psl->size - 1;
	//while (end >= (int)pos)  //会有隐式转换，把int转化为unsigned int,所以可以把pos强转成int
	//{
	//	psl->arr[end + 1] = psl->arr[end];
	//	end--;
	//}
	
	//psl->arr[pos] = x;
	//psl->size++;

	size_t end = psl->size; //这样可以避免死循环的问题
	while (end > pos)
	{
		psl->arr[end] = psl->arr[end - 1];
		end--;
	}

	psl->arr[pos] = x;
	psl->size++;

}

在pos位置插入数据时，需要把pos后面的数据依次往后挪动一位。

9.在头部删除数据

void SeqListPopFront(SL* psl)
{
	assert(psl);//断言：防止psl为空

	//从前往后挪动数据
	/*int begin = 0;
	while (begin < psl->size - 1)
	{
		psl->arr[begin] = psl->arr[begin + 1];
		begin++;
	}
	psl->size--;*/

	int begin = 1;
	while (begin < psl->size)
	{
		psl->arr[begin - 1] = psl->arr[begin];
		begin++;
	}
	psl->size--;

	//调用SeqListErase函数
	//SeqListErase(psl, 0);
}

在头部删除数据时，需要将数据从前往后挪动一位**(注意是从前往后挪动，否则其他数据会被覆盖)**

10.在尾部删除数据

void SeqListPopBack(SL* psl)
{
	assert(psl);//断言：防止psl为空

	//调用SeqListErase函数
	//SeqListErase(psl, psl->size - 1);

	//如果尾部有数据，直接让psl->size--即可
	psl->size--;
}

如果尾部有数据，size–即可。

11.删除pos位置的数据

void SeqListErase(SL* psl, size_t pos)
{
	assert(psl);//断言：防止psl为空

	int end = pos;
	while (end < psl->size - 1)
	{
		psl->arr[end] = psl->arr[end + 1];
		end++;
	}
	psl->size--;

	//调用SeqListErase函数
	//SeqListErase(psl, pos);
}

把pos位置后面的数据依次往前挪动即可。

12.查找数据

int SeqListFind(SL* psl, SLDataType x)
{
	assert(psl);//断言：防止psl为空

	//遍历查找
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		if (x == psl->arr[i])
		return i;
	}

	return -1;//没有找到返回-1
}

13.修改pos 位置的数据

void SeqListModify(SL* psl, size_t pos, SLDataType x)
{
	assert(psl);//断言：防止psl为空
	assert(pos <= psl->size);//删除数据的位置要小于psl>size

	psl->arr[pos] = x;//修改数据
}

面试题：删除数据需要扩容吗？

我们知道，在插入数据时，在空间不够的时候，我们需要进行扩容，那么，我们在删除数据之后需要把空间返还给内存(缩容)吗？答案是不会。原因如下：

第一：我们缩容之后插入数据有需要重新进行扩容，我们知道，ralloc函数扩容是有代价的：扩容分为原地扩容和异地扩容。

原地扩容：当原来的空间后面有足够的可利用空间时，操作系统会直接把那一块空间交给我们使用，这种情况对效率的影响不大；

异地扩容：当原来空间后面没有足够的可利用的空间时，操作系统会在另外足够的地方为我们开辟一块新的空间，再把我们原来空间中的数据拷贝到新的空间中，再把原来的空间释放掉，这种情况对效率的影响就比较大了。

所以，频繁的扩容使用效率损失的。

第二：缩容也是有代价的，因为缩容和扩容的过程是一样的，分为原地扩和异地扩，会对程序的效率造成一定的影响。

第三：顺序表的申请是连续的一块空间，而free函数不能释放申请空间的一部分，只能一起释放。这就好比，我们团购优惠住酒店，你说你不住了，那时候就不能享受优惠了，因为团购才能有优惠，所以只能同时住和不住。在内存中申请空间和释放空间也是如此，所以我们做不到只释放一部分空间。

四、完整代码

1.SeqList.h

#define _CRT_SECURE_NO_WARNINGS 1

#pragma once      //防止头文件被重复包含

//#ifndef __SEQLIST_H__
//#define _SEQLIST_H__
// ......
//#endif

//包含头文件
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//结构的定义和符号的表示
//静态顺序表
//#define N 100 //数组的最大长度
//typedef int SLDataType; //重命名数据类型
//struct SeqList
//{
//	SLDataType arr[N];    //使用定长数组来存储数据
//	int size;            //存储数据的个数
//}SL;


//动态顺序表
typedef int SLDataType;//将数据类型重命名为SLDataType
typedef struct SeqList
{
	SLDataType* arr;      //存储空间的地址
	int size;             //存储数据的个数
	int capacity;         //存储空间的大小
}SL;                      //重定义为SL


//函数的声明(函数接口)

//顺序表的初始化
void SeqListInit(SL* psl);
//检查顺序表的容量
void CheckCapacity(SL* psl);
//顺序表的销毁
void SeqListDestroy(SL* psl);
//打印顺序表中的数据
void SeqListPrint(SL* psl);
//在头部插入数据
void SeqListPushFront(SL* psl, SLDataType x);
//在尾部插入数据
void SeqListPushBack(SL* psl, SLDataType x);
//在pos位置插入数据
void SeqListInsert(SL* psl, size_t pos, SLDataType x);
//在头部删除数据
void SeqListPopFront(SL* psl);
//在尾部删除数据
void SeqListPopBack(SL* psl);
//删除pos位置的数据
void SeqListErase(SL* psl, size_t pos);
//查找数据     没有找到就返回-1
int SeqListFind(SL* psl, SLDataType x);
//修改pos位置数据
void SeqListModify(SL* psl, size_t pos, SLDataType x);

2.SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "SeqList.h"

//顺序表的初始化
void SeqListInit(SL* psl)
{
	assert(psl);//断言：防止psl为空


	psl->arr = NULL;
	psl->size = psl->capacity = 0;
}

//检查顺序表的容量(扩容)
//空间为0时开辟4个字节的空间，否则扩容2倍
void CheckCapacity(SL* psl)
{
	//检查容量
	if (psl->size == psl->capacity)
	{
		//将realloc的返回值由一个临时变量保存，防止扩容失败后丢失原来的空间地址
		int newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;
		SLDataType* tmp = (int*)realloc(psl->arr, newCapacity * sizeof(SLDataType));
		if (tmp == NULL)//判空
		{
			perror("realloc fail");//打印错误信息
			return;
			//exit(-1);//退出程序
		}

		psl->arr = tmp;//开辟的空间地址赋给psl->arr
		psl->capacity = newCapacity;//新的空间大小
	}
}

//顺序表的销毁
void SeqListDestroy(SL* psl)
{
	assert(psl);//断言：防止psl为空

	/*if (psl->arr)
	{*/
		free(psl->arr); //释放(避免内存泄漏)
		psl->arr = NULL;//指针置空(避免野指针)
		psl->size = psl->capacity = 0;
	//}
}

//打印顺序表中的数据
void SeqListPrint(SL* psl)
{
	assert(psl);//断言：防止psl为空

	//遍历数组
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->arr[i]);
	}

	printf("\n");

}

//在头部插入数据
void SeqListPushFront(SL* psl, SLDataType x)
{
	assert(psl);//断言：防止psl为空

	CheckCapacity(psl);//检查容量，空间不够时扩容

	//从后往前挪动数据
	int end = psl->size - 1;
	while (end >= 0)
	{
		psl->arr[end + 1] = psl->arr[end];
		end--;
	}

	psl->arr[0] = x;
	psl->size++;

	//调用Insert函数
	//SLInsert(psl, 0, x);
}

//在尾部插入数据
void SeqListPushBack(SL* psl, SLDataType x)
{
	assert(psl);//断言：防止psl为空

	CheckCapacity(psl);//检查容量，空间不够时扩容

	psl->arr[psl->size] = x;
	psl->size++;

	//调用Insert函数
	//SLInsert(psl, psl->size, x);
}

//在pos位置插入数据
void SeqListInsert(SL* psl, size_t pos, SLDataType x)
{
	assert(psl);//断言：防止psl为空
	assert(pos <= psl->size);//不能在psl->size之后插入

	CheckCapacity(psl);//检查容量，空间不够时扩容

	//int end = psl->size - 1;
	//while (end >= (int)pos)  //会有隐式转换，把int转化为unsigned int,所以可以把pos强转成int
	//{
	//	psl->arr[end + 1] = psl->arr[end];
	//	end--;
	//}
	
	//psl->arr[pos] = x;
	//psl->size++;

	size_t end = psl->size; //这样可以避免死循环的问题
	while (end > pos)
	{
		psl->arr[end] = psl->arr[end - 1];
		end--;
	}

	psl->arr[pos] = x;
	psl->size++;

}

//在头部删除数据
void SeqListPopFront(SL* psl)
{
	assert(psl);//断言：防止psl为空

	//从前往后挪动数据
	/*int begin = 0;
	while (begin < psl->size - 1)
	{
		psl->arr[begin] = psl->arr[begin + 1];
		begin++;
	}
	psl->size--;*/

	int begin = 1;
	while (begin < psl->size)
	{
		psl->arr[begin - 1] = psl->arr[begin];
		begin++;
	}
	psl->size--;

	//调用SeqListErase函数
	//SeqListErase(psl, 0);
}

//在尾部删除数据
void SeqListPopBack(SL* psl)
{
	assert(psl);//断言：防止psl为空

	//调用SeqListErase函数
	//SeqListErase(psl, psl->size - 1);

	//如果尾部有数据，直接让psl->size--即可
	psl->size--;
}

//删除pos位置的数据
void SeqListErase(SL* psl, size_t pos)
{
	assert(psl);//断言：防止psl为空

	int end = pos;
	while (end < psl->size - 1)
	{
		psl->arr[end] = psl->arr[end + 1];
		end++;
	}
	psl->size--;

	//调用SeqListErase函数
	//SeqListErase(psl, pos);
}

//查找数据     没有找到就返回-1
int SeqListFind(SL* psl, SLDataType x)
{
	assert(psl);//断言：防止psl为空

	//遍历查找
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		if (x == psl->arr[i])
		return i;
	}

	return -1;//没有找到返回-1
}

//修改pos位置数据
void SeqListModify(SL* psl, size_t pos, SLDataType x)
{
	assert(psl);//断言：防止psl为空
	assert(pos <= psl->size);//删除数据的位置要小于psl>size

	psl->arr[pos] = x;//修改数据
}

3.test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "SeqList.h"

//测试插入数据
void TestSeqList1()
{
	SL sl;
	SeqListInit(&sl);

	//在头部插入数据
	SeqListPushFront(&sl, 1);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 3);
	SeqListPushFront(&sl, 4);

	SeqListPrint(&sl);

	//在尾部插入数据
	SeqListPushBack(&sl, 5);
	SeqListPushBack(&sl, 6);

	SeqListPrint(&sl);

	//在pos位置插入数据
	SeqListInsert(&sl, 0, 7);

	SeqListPrint(&sl);
}

//测试删除数据
void TestSeqList2()
{
	SL sl;
	SeqListInit(&sl);

	//在头部插入数据
	SeqListPushFront(&sl, 1);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 3);
	SeqListPushFront(&sl, 4);
	SeqListPushFront(&sl, 5);
	SeqListPushFront(&sl, 6);

	SeqListPrint(&sl);

	//删除头部数据

	SeqListPopFront(&sl);
	SeqListPopFront(&sl);

	SeqListPrint(&sl);

	//删除尾部数据
	SeqListPopBack(&sl);

	SeqListPrint(&sl);

	//删除pos位置数据
	SeqListErase(&sl, 0);

	SeqListPrint(&sl);

	//查找数据
	int ret = SeqListFind(&sl, 2);
	printf("%d\n", ret);

	//修改pos位置的数据为10
	SeqListModify(&sl, 1,10);

	SeqListPrint(&sl);

}


int main()
{
	//TestSeqList1();
	TestSeqList2();
	return 0;
}

五、顺序表的缺陷

顺序表存在以下缺陷：

\1. 中间/头部的插入删除，时间复杂度为O(N)

\2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。

\3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到

200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

椿融雪
关注
  • 23
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 21
    评论
专栏目录
【数据结构】顺序表（C语言实现）
carl_2018的博客
05-24 801
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。顺序表一般可以分为静态顺序表（使用定长数组存储）和动态顺序表（使用动态开辟的数组存储）。本次实现的是动态顺序表，具体代码如下： common.h #include <stdio.h> #include <stdlib.h> #include <asser...
数据结构——顺序表（C语言实现）
SDULKP的博客
06-09 1592
顺序表的定义和特点           顺序表的定义是：把线性表中所有表项按照其逻辑顺序依次存储到从计算机存储中指定存储位置开始的一块连续的存储空间中。这样，线性表中第一个表项的存储位置就是被指定的存储位置，第i个表项（2 ≤ i ≤ n）的存储位置紧接在第i - 1个表项的存储位置的后面。假设顺序表中每个表项的数据类型为T，则每个表项所占用存储空间的大小相同，均为sizeof（T），整个顺序表
【数据结构】C语言实现基本顺序表——增删查改
2301_77438812的博客
10-30 443
静态顺序表的定长数组导致N定大了，空 间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间 大小，所以下面我们实现动态顺序表。任意位置插入：void SLInsert(SL* psl, int pos, SLDataType x)然后我们就可以实现增删查改了，为了保证函数的正确性，建议写一个函数就自行测试以下。为了便于检查，我们先对顺序表的初始化，打印，和销毁函数进行实现。打印：void SLDestroy(SL* psl)2：动态顺序表：使用动态开辟的数组存储。
用C语言实现顺序表的增删查改和逆置
Monster_Girl
09-08 2724
顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。
顺序表的修改算法c语言,数据结构顺序表表相关算法的C语言实现
weixin_30095343的博客
05-20 412
#include#include#define LIST_INIT_SIZE 100#define LISTCREMENT 10#define ElemType inttypedef struct{ElemType * elem;int length;int listsize;}Sqlist;void InitList_Sq(Sqlist &L){L.elem=(ElemType*)mal...
C语言实现顺序表(增,删,改,查)
lh11223326的博客
03-27 1054
数据结构和算法概述-CSDN博客。
顺序表的插入，删除，修改和查找（详细解析）
weixin_69884785的博客
08-14 3800
顺序表的插入，删除，修改和查找（详细解析）相对基础，多看多理解多写
C语言-数据结构课程设计+实验报告
07-08
基于数据结构中顺序表和链表的实验设计，包括顺序表和链表的增删查改的实现及相关的应用案例。 编译器：C-Free 5.0 语言：C语言 主要内容： 1.顺序表 （1）要求从文件中读取数据，进行基本的增删改查，简单的排序...
设计顺序表的相关函数库 —— 数据结构课程设计
07-09
顺序表基本操作比如增删查改都有对应函数 很简单 而报告内容包含1.设计简介及设计方案论述 2 函数库中的函数 3.课程设计思路 + 代码实现分析 4. 总结与思考 本资源将前面所要实现的要求，基本都满足，购买者如若还有...
c语言数据结构线性表实验（包括顺序表和链表）
11-28
而`SqList`则可能对应顺序表的实现，包括数组的初始化、动态扩容、元素的增删查改等。 实验可能涵盖了以下知识点： 1. **数据结构基础**：理解线性表的概念，学习顺序表和链表的区别。 2. **C语言编程**：使用指针...
双向循环链表、增删查改、判断回文、排序、论文+代码
07-25
本资源摘要信息主要针对数据结构与算法课程设计，涵盖双向循环链表、增删查改、判断回文、排序等知识点。下面将对每个知识点进行详细的解释和分析。 一、双向循环链表 双向循环链表是一种特殊的链表结构，它具有...
C语言期末大作业：用顺序存储结构实现图书管理系统
09-20
在本项目中，"C语言期末大作业：用顺序存储结构实现图书管理系统"是一个实践性的编程任务，旨在让学生掌握C语言编程基础以及数据结构中的顺序存储结构应用。这个系统允许用户进行一系列图书管理操作，包括图书信息的...
【数据结构】顺序表的增删查改 (C语言实现)
在平淡的日子里寻找存在的价值
08-03 3654
用C语言实现的对顺序表的增删查改操作以及相关OJ题练习。
顺序表----增删查改（C语言版）
折木的博客
02-15 1030
前言 顺序表是线性表的一种，是实际中运用非常广泛的一种数据结构，也应该是每一个初学者所接触到的第一种数据结构。所谓万事开头难，学好顺序表实现就是为数据结构的学习开了一个好头。 顺序表一般分为两种，一种为静态顺序表，实质上是一个静态的数组。还有一种是动态顺序表，动态顺序表的内存可以根据使用者需求来自主调整大小。本篇文章我将主要向大家介绍动态顺序表的以下功能：初始化、销毁、打印、尾插、尾删、头插、头删、查找、任意位置的插入、任意位置的删除。 每一个功能我都会向大家展示相应的效果，并且分析它就是如何来实现的，下面
顺序表的基本操作：增删改查（含全部代码，C语言实现）——数据结构线性表
weixin_61125362的博客
10-29 355
数据结构学习基础---基本操作，C语言。1顺序表定义；2顺序表初始化；3检查增容；4销毁顺序表；5尾插；6尾删；7头插；8头删；9打印元素； 10查找元素返回下标；11指定元素插入；12删除指定元素；完整代码
【 数据结构 】顺序表的实现 - 详解（C语言版）
上上谦. 的博客
03-13 8050
目录 前言 线性表： ​ 顺序表： 概念及结构： 顺序表的实现： 头文件：SeqList.h realloc函数讲解： 具体函数的实现：SeqList.c 顺序表的初始化： 顺序表的打印： 容量的检查： 顺序表的尾插： 顺序表的尾删： 顺序表的头插： 顺序表的头删： 在顺序表的指定位置插入数据： 在顺序表的指定位置删除数据： 顺序表的查找： 顺序表的修改： 顺序表的销毁： 数组越界的检查： 前言 简单用C语言来描述数据结构中的顺序表......
C语言实现顺序表（图解增删查改+代码）
m0_50655389的博客
10-22 822
顺序表是一种基本的数据结构，它是一种线性表，其元素在内存中是连续存储的。本篇文章以c语言的形式实现了数据结构中的顺序表。
C语言实现顺序表增删查改操作
春天的熊的博客
04-10 7937
C语言实现顺序表增删查改操作线性表是最常用且最简单的一种数据结构。线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。结构如下图图片来自百度 为了描述顺序表，我们声明一个结构，如下： #define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量 #define LIST_INCREMENT 10 //线性表存储空间的分配增量typedef int Elem
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
最新发布
铁匠匠匠的博客
07-18 1058
可以参考以下视频。
顺序表增删查改的时间自由度
04-04
顺序表的增、删、查、改操作的时间复杂度取决于数据规模和操作的位置。 增操作：在顺序表的末尾进行插入操作的...因此，顺序表的增删查改操作的时间自由度相对较低，操作的时间复杂度取决于具体的操作位置和数据规模。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

椿融雪

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

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

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

打赏作者

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

抵扣说明：

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

余额充值