C语言——顺序表的实现(数据结构)

最新推荐文章于 2024-07-01 21:59:15 发布
最新推荐文章于 2024-07-01 21:59:15 发布
阅读量815 收藏 13
点赞数 32
分类专栏： 数据结构 文章标签： c语言 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63207201/article/details/137784964
版权

目录

 一，完整代码

SeqList.h

SeqList.c

test.c

二，整体过程

 初始化结构体

尾插

打印

 尾删

头插

头删

任意位置的插入&&删除

 顺序表的查找

顺序表的销毁

前言：
顺序表就是一个可以动态增长的数组，顺序表就是对数组进行增删改查的操作。
性质: 1，可动态增长的数组    2，数据在数组中存储时必须是连续的
优点: 1，可以随机访问。 2，缓存命中率比较高。
缺点：中间或者头部插入删除很慢，需要挪动数据，需要扩容，会造成空间的浪费。尾插尾删快，头插头删慢时间复杂度O(N)，因为需要挪动数据,,顺序表的缺点正好可以由链表的优点来弥补。
链表不好排序，不能进行随机访问，顺序表和链表优势互补。

 一，完整代码

SeqList.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLDataType;
#define MAX_INT 4
#define ADD_CAP 4
typedef struct SeqList
{
	SLDataType* a;
	int size;   //有效数据个数
	int capacity; // 容量
}SL,SeqList;
//初始化结构体
void SeqListInit(SL* ps);
//检测是否需要增容
void SeqListCheckCapacity(SL* ps);

//尾插
void SeqListPushBack(SL* ps, SLDataType x);
//尾删
void SeqListPopBack(SL* ps);
//打印
void SeqListPrint(SL* ps);
//头插头删
void SeqListPushFront(SL* ps, SLDataType x);
void SeqListPopFront(SL* ps);
//任意位置的插入删除
void SeqListInsert(SL* ps, int pos, SLDataType x);
void SeqListErase(SL* ps, int pos);
//顺序表查找
int SeqListFind(SL* ps1, SLDataType x);
//销毁,动态开辟的空间需要主动销毁
void SeqListDestory(SL* ps);

SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"
//初始化结构体
void SeqListInit(SL* ps) 
{
	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * MAX_INT);
	if (ps->a == NULL)
	{
		printf("申请内存失败\n");
		exit(-1);
	}
	ps->size = 0;
	ps->capacity = MAX_INT;
}
//检测是否需要增容
void SeqListCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		//增容, 增加2倍比较合适，因为频繁增容会增加函数的开销
		/*SLDataType* pr = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * (ADD_CAP + ps->capacity));*/
		ps->capacity *= 2;
		SLDataType* pr = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->capacity);
		if (pr != NULL)
		{
			ps->a = pr;
		}
		else
		{
			return;
		}
	}
}
//尾插
void SeqListPushBack(SL* ps, SLDataType x) 
{
	assert(ps);
	SeqListCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}
//打印
void SeqListPrint(SL* ps) 
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++) 
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
//尾删
void SeqListPopBack(SL* ps) 
{
	assert(ps);
	ps->size--;
}
//头插
void SeqListPushFront(SL* ps, SLDataType x) 
{
	assert(ps);
	SeqListCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0) 
	{
		ps->a[end+1] = ps->a[end];
		--end;
	}
	ps->a[0] = x;
	ps->size++;
}
//头删
void SeqListPopFront(SL* ps) 
{
	assert(ps);
	int start = 0;
	while (start < ps->size - 1) 
	{
		ps->a[start] = ps->a[start + 1];
		++start;
	}
	ps->size--;
}
//任意位置的插入删除
void SeqListInsert(SL* ps, int pos, SLDataType x) 
{
	assert(ps);
	assert(pos < ps->size && pos >= 0);
	SeqListCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos) 
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}
void SeqListErase(SL* ps, int pos) 
{
	assert(pos);
	assert(pos < ps->size && pos >= 0);
	int start = pos;
	while (start < ps->size - 1)
	{
		ps->a[start] = ps->a[start + 1];
		++start;
	}
	ps->size--;
}

//顺序表查找,返回下标
int SeqListFind(SL* ps, SLDataType x) 
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++) 
	{
		if (ps->a[i] == x) 
		{
			return i;
		}
	}
	return -1; // 没有找到
}

//销毁,动态开辟的空间需要主动销毁
void SeqListDestory(SL* ps) 
{
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"
void TestSeqList1() 
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 6);
	SeqListPushBack(&s, 7);
	SeqListPushBack(&s, 8);
	SeqListPushBack(&s, 9);
	SeqListPushBack(&s, 10);
	SeqListPrint(&s);
	//销毁动态开辟的空间
	SeqListDestory(&s);
}
int main() 
{
	TestSeqList1();
	return 0;
}

二，整体过程

 初始化结构体

SeqList.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLDataType;
#define MAX_INT 4
#define ADD_CAP 4
typedef struct SeqList
{
	SLDataType* a;
	int size;   //有效数据个数
	int capacity; // 容量
}SL,SeqList;
//初始化结构体
void SeqListInit(SL* ps);

SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"
//初始化结构体
void SeqListInit(SL* ps) 
{
	/*s.size = 0;
	s.a = NULL;
	s.capacity = 0;*/
	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * MAX_INT);
	if (ps->a == NULL)
	{
		printf("申请内存失败\n");
		exit(-1);
	}
	ps->size = 0;
	ps->capacity = MAX_INT;
}

test.c

void TestSeqList1() 
{
	SeqList s;
	SeqListInit(&s);
}
#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"
int main() 
{
	TestSeqList1();
	return 0;
}

 首先把顺序表的结构定义好，我们使用数组来动态开辟空间保存顺序表中的数据动态增长的顺序表，可以实现动态增长
定义数组指针a指向动态开辟的空间
定义size记录数据的有效个数
定义capacity记录当前顺序表的最大容量

尾插

SeqList.h

//尾插
void SeqListPushBack(SL* ps, SLDataType x);

SeqList.c

void SeqListPushBack(SL* ps, SLDataType x) 
{
	assert(ps);
	if (ps->size == ps->capacity)
    {
	 ps->capacity *= 2;
	 SLDataType* pr = (SLDataType*)realloc(ps->a,sizeof(SLDataType) * ps->capacity);
	if (pr != NULL)
	{
		ps->a = pr;
	}
	else
	{
		return;
    }
   }
	ps->a[ps->size] = x;
	ps->size++;
}

 这里增容可以自行选择增加的大小，建议增加2倍，因为频繁的realloc增容会增加函数的开销。通常我们使用realloc修改原来的空间都使用一个新的指针pr来接收，如果我用ps->a来保存这个地址的话就会有问题，因为realloc修改空间大小空间不足时候失败会返回NULL(一般情况都是不会失败的)，就会使得ps->变成NULL本来存在一个有效地址结果变成空指针，这样会导致内存泄漏。

test.c

void TestSeqList1() 
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 6);
	SeqListPushBack(&s, 7);
	SeqListPushBack(&s, 8);
	SeqListPushBack(&s, 9);
	SeqListPushBack(&s, 10);
}

 为了能好的测试出来结果，我们现在把打印功能完善一下。

打印

SeqList.h

//打印
void SeqListPrint(SL* ps);

SeqList.c

//打印
void SeqListPrint(SL* ps) 
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++) 
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

test.c

void TestSeqList1() 
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 6);
	SeqListPushBack(&s, 7);
	SeqListPushBack(&s, 8);
	SeqListPushBack(&s, 9);
	SeqListPushBack(&s, 10);
	SeqListPrint(&s);
}

测试结果如下: 

 尾删

SeqList.h

//尾删
void SeqListPopBack(SL* ps);

SeqList.c

void SeqListPopBack(SL* ps) 
{
	assert(ps);
	ps->size--;
}

test.c

void TestSeqList1() 
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 6);
	SeqListPushBack(&s, 7);
	SeqListPushBack(&s, 8);
	SeqListPushBack(&s, 9);
	SeqListPushBack(&s, 10);
	SeqListPrint(&s);
	//尾删
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPrint(&s);
	}

 测试结果如下：

头插

SeqList.h

//检测是否需要增容
void SeqListCheckCapacity(SL* ps);
//头插
void SeqListPushFront(SL* ps, SLDataType x);

SeqList.c

//检测是否需要增容
void SeqListCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		ps->capacity *= 2;
		SLDataType* pr = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->capacity);
		if (pr != NULL)
		{
			ps->a = pr;
		}
		else
		{
			return;
		}
	}
}
void SeqListPushFront(SL* ps, SLDataType x) 
{
	assert(ps);
	SeqListCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0) 
	{
		ps->a[end+1] = ps->a[end];
		--end;
	}
	ps->a[0] = x;
	ps->size++;
}

 1，写到这里我们发现，头插和尾插一样，最先都要进行判断容量，如果不足就需要增容，这里我们可以单独写一个增容的函数，方便调用，在尾插也可以把那一段代码修改成SeqListCheckCapacity
2，头插就需要我们挪动数据进行插入

解下如下：

test.c

void TestSeqList1() 
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 6);
	SeqListPushBack(&s, 7);
	SeqListPushBack(&s, 8);
	SeqListPushBack(&s, 9);
	SeqListPushBack(&s, 10);
	SeqListPrint(&s);
   //头插
   SeqListPushFront(&s, -1);
   SeqListPushFront(&s, -2);
   SeqListPushFront(&s, -3);
   SeqListPrint(&s);
}

测试结果如下：

头删

SeqList.h

//头删
void SeqListPopFront(SL* ps);

SeqList.c

void SeqListPopFront(SL* ps) 
{
	assert(ps);
	int start = 0;
	while (start < ps->size - 1) 
	{
		ps->a[start] = ps->a[start + 1];
		++start;
	}
	ps->size--;
}

 原理和头插一样，也需要挪动数据，把数据的后一位给前一位
解析下如图所示:

test.c

void TestSeqList1() 
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 6);
	SeqListPushBack(&s, 7);
	SeqListPushBack(&s, 8);
	SeqListPushBack(&s, 9);
	SeqListPushBack(&s, 10);
	SeqListPrint(&s);
	//头删
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPrint(&s);
}

测试结果如下：

任意位置的插入&&删除

SeqList.h

//任意位置的插入删除
void SeqListInsert(SL* ps, int pos, SLDataType x);
void SeqListErase(SL* ps, int pos);

SeqList.c

//任意位置的插入删除
void SeqListInsert(SL* ps, int pos, SLDataType x) 
{
	assert(ps);
	assert(pos < ps->size && pos >= 0);
	SeqListCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos) 
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}
void SeqListErase(SL* ps, int pos) 
{
	assert(pos);
	assert(pos < ps->size && pos >= 0);
	int start = pos;
	while (start < ps->size - 1)
	{
		ps->a[start] = ps->a[start + 1];
		++start;
	}
	ps->size--;
}

1，任意位置的插入删除其原理和头插头删一样的，只不过区间范围缩小了
2， 头插的区间范围是[0,ps->size-1]
 任意位置的插入就是[pos,ps->size-1],
同样我们定义变量end，end不断减减，头插结束位置是下标0，而任意位置插入结束位置是pos.
 3，头删的区间范围是[0,ps->size-1]
 任意位置的删除就是[pos,ps->size-2],
 同样我们定义变量start，start不断加加，
 头删开始下标是0结束位置是下标ps->size-2。
而任意位置插入开始位置下标是pos，结束位置下标是ps->size-2。

test.c

测试结果如下:

 顺序表的查找

SeqList.h

//顺序表查找
int SeqListFind(SL* ps1, SLDataType x);

SeqList.c

//顺序表查找,返回下标
int SeqListFind(SL* ps, SLDataType x) 
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++) 
	{
		if (ps->a[i] == x) 
		{
			return i;
		}
	}
	return -1; // 没有找到
}

test.c

void TestSeqList1() 
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 6);
	SeqListPushBack(&s, 7);
	SeqListPushBack(&s, 8);
	SeqListPushBack(&s, 9);
	SeqListPushBack(&s, 10);
	SeqListPrint(&s);
	//顺序表的查找，查找到某个数
	int pos = SeqListFind(&s, 3);
	if (pos != -1) 
	{
		SeqListErase(&s, pos);
	}
	SeqListPrint(&s);
}

测试结果如下：

顺序表的销毁

SeqList.h

//销毁
void SeqListDestory(SL* ps);

SeqList.c

//销毁
void SeqListDestory(SL* ps) 
{
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

test.c

void TestSeqList1() 
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 6);
	SeqListPushBack(&s, 7);
	SeqListPushBack(&s, 8);
	SeqListPushBack(&s, 9);
	SeqListPushBack(&s, 10);
	SeqListPrint(&s);
	//销毁动态开辟的空间
	SeqListDestory(&s);
}

daiyanyun
关注
专栏目录
数据结构实验报告1 顺序表的实现
weixin_45994596的博客
12-20 692
数据结构实验报告1
数据结构C语言——静态顺序表的实现
m0_59086544的博客
06-17 500
本文章主要是介绍关于数据结构中用C语言来实现顺序表的一些基本操作。
顺序表（C语言实现）
trqii_的博客
04-26 5224
顺序表 文章目录顺序表一、**顺序表的基本概念**二、动态顺序表的具体实现1. 顺序表初始化2. 顺序表尾插3. 顺序表头插4. 顺序表尾删5. 顺序表头删6. 顺序表任意位置插入7. 顺序表任意位置删除8. 顺序表查找9. 顺序表修改10. 顺序表打印11. 顺序表销毁三、完整代码 一、顺序表的基本概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表分为以下二类： 1.静态顺序表：使用定长数组存储元素。 #define N
顺序表（C语言详细版）
最新发布
李白同学的博客
07-01 728
线性表(lina list)是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串......线性表在逻辑上是线性结构，也就是说连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
数据结构c语言实验报告 顺序表的实现,数据结构C语言实现之顺序表
weixin_32999557的博客
05-22 233
#include //宏定义顺序表的空间大小#define LISTSIZE 20//宏定义函数返回值#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0//类型定义typedef int ElemType;//函数返回状态类型定义typedef int State;//声明顺序表类型结构体typedef struct _SqList{E...
数据结构——顺序表（C语言实现）
2301_80485318的博客
05-01 248
一、基本概念一、基本概念概念：用一组地址连续的存储单元依次存储线性表的数据元素即顺序存储结构。特点：逻辑上相邻的数据元素，物理次序上也相邻。顺序表分为静态顺序表和动态顺序表，且在生活中常用的也是动态顺序表。这是因为静态顺序表提前开辟空间可能会导致空间开辟过多或空间不足的情况，而动态顺序表则会避免这个问题。顺序表的主要实现的就是对数据的增删查改。二、重难解析malloc函数：指针名 = (指针类型*）malloc（sizeof（指针类型）*数据数量）
数据结构C语言：顺序表实现
myscratch的博客
07-27 378
数据结构顺序表的C语言实现
C语言——基于顺序表的学生信息管理系统（文件操作）
12-21
总的来说，"C语言——基于顺序表的学生信息管理系统（文件操作）"是一个结合了基础数据结构和文件I/O操作的实践项目。它可以帮助学习者巩固C语言编程技能，理解数据结构的实用价值，以及如何在实际应用中进行文件...
数据结构C语言——动态顺序表的实现
m0_59086544的博客
06-17 861
本篇文章主要介绍的是数据结构中使用C语言来实现动态顺序表的一些基本操作。
数据结构C语言——广义表
White100的博客
03-22 1万+
很久没有发博客记录了，不过应该也没人关心这个，哈哈哈。 突然想起来，学习也不能只是干学，稍微做点记录。 之前我对html、css、js基础有了一定的理解，也学了一些模板，不过现在我想先把计算机基础给补上，所以把数据结构理一理！ 近在学习数据结构C语言版，有一些心得，跟大家分享一下 可能会有很多比较基础的知识，大佬勿喷！ ok，我现在在学习广义表的结构，前边学的其他数据结构我后边会找时间在整理一下。下边是我对广义表的一些理解，大家可以适当的参考一下，如果方便的话，也麻烦帮我指出不足之处，给我这个想要继续往上的
数据结构纯C语言版——顺序表实现及有序表的定义
m0_46198383的博客
03-28 1882
顺序表的实现、顺序表数据类型定义——动态分配、初始化、销毁、清除、判断是否为空、在位置i上插入元素e 、删除第i个元素并返回元素值 、删除第一个值位e的元素并返回查找第一个值为e的元素并返回元素位置、/将第i个位置的元素替换为e、获取顺序表的长度、获取第i个数据元素的值、归并算法实现——有序表的合并
【数据结构】顺序表的实现（C语言）
m0_74055118的博客
04-16 638
顺序表的实现方法
数据结构之顺序表的实现（c语言）
m0_64334842的博客
11-03 428
因为静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数据导致长度定大，空间开多了浪费，开少了不够用。所以现实中基本使用的动态顺序表，根据需要动态的分配空间大小。所以主要实现动态顺序表。
数据结构--顺序表的c语言实现（超详细注释/实验报告）
热门推荐
池塘春草梦的博客
09-25 1万+
线性表是一种最基本、最常用的数据结构，它有两种存储结构——顺序表和链表。顺序表是由地址连续的的向量实现的，便于实现随机访问。顺序表进行插入和删除运算时，平均需要移动表中大约一半的数据元素，容量难以扩充。
数据结构-C语言实现顺序表
lijiedebiancheng的博客
11-15 2624
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define ERROR 0 #define LIST_INIT_SIZE 100 #define LISTINCREAMENT 10 #define OK 1 #define OVERFLOW -1 #define TURE 1 #define FALSE 0 typedef int Status...
数据结构（c语言版）顺序表的实现
ChunkWen的博客
09-12 1690
数据结构原本的书籍上面只写了算法部分，不能直接运行，在此贴上c语言实现的完整代码，需要注意的地方已在代码中注释 #include <stdio.h> #include <malloc.h> #define LIST_SIZE 100//初始分配空间的节点个数 #define LIST_INCREMENT 10//新分配空间的节点个数 typedef int ElemType; typedef struct book{ ElemType* elem;//存储空间基地址 int
数据结构——顺序表的实现
2301_78912147的博客
03-01 852
int size;//有效数据//capacity表示空间的容量}SL;注：typedef int SLDataType;这个语句中，将int类型重命名为SLDataType。通过这个typedef声明，可以在代码中使用SLDataType来代替int类型。在后续的代码中，将直接使用SLDataType来声明变量，而不必再使用int类型。这里命名了一个名为SeqList的顺序表，其中size表示此顺序表内的数据个数，capacity表示此顺序表所能容纳的数据个数。
【数据结构】C语言实现顺序表万字详解(附完整运行代码)
C/C++领域,数据结构,linux,MySQl学习者
10-28 815
使用C语言实现顺序表程序的新手入门万字详解,包括每个函数的设计原理图示,设计思路,每步的注释以及程序完整实现代码.
【数据结构】C语言实现顺序表（超级详细）
m0_74459723的博客
01-01 1万+
顺序表作为线性表的一种，它是用一段数据元素的线性结构，一般情况下采用。在数组上完成数据的增删查改。顺序表一般分为：1、静态顺序表——使用定长数组进行存储元素。这种存储方式在存储数据时比较有局限性，当数据存储量非常小的时候，数组长度太长，会造成空间的浪费；当数据存储量非常大的时候，数组空间可能会不够，但是这种存储方式不能进行扩容。所以在实现顺序表时，我们通常使用的是动态顺序表。这样能够提高我们的空间利用率。2、动态顺序表——使用动态开辟的数组进行存储元素。
C语言实现数据结构：顺序表操作实验指南
"数据结构实验指导书C语言版主要涵盖了线性表的顺序存储结构——顺序表的操作，包括建立、插入、删除和查找等基本操作。实验旨在通过C语言编程实现，让学生掌握顺序表的表示和实现方法，熟悉相关算法，并进行实际...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值