数据结构：顺序表-C语言实现

已于 2022-03-04 15:20:02 修改
阅读量817 收藏 12
点赞数 12
分类专栏： 数据结构初级阶段-C语言实现 文章标签： 数据结构 c语言
于 2021-11-06 14:25:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yohe1937/article/details/121178148
版权

数据结构-顺序表

文章目录

目录

  • 线性表
  • 顺序表
  • 链表
  • 顺序表和链表的优缺点

线性表

线性表是n个具有相同特性的数据元素的有限序列，逻辑上是线性结构，是一条连续的直线。物理结构上不一定连续，因为通常线性表在内存中是以数组和链式的形式存储，以数组形式存储时是连续的，但是以链式形式存储时是不连续的。常见的线性表：顺序表、链表、栈、队列… 这篇文章先给大家介绍顺序表，链表、栈和队列会在后续文章更新。

顺序表

定义

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

  • 静态顺序表和动态顺序表

在这里插入图片描述

通过上述可知，静态顺序表为定长的数组，导致MaxSize定大了，空间开多了浪费，开少了不够用，实际使用场景有限。所以现实中基本都是使用动态顺序表，根据需要可以用realloc动态地分配空间大小，所以下面我们实现动态顺序表。本次代码的实现共创建了三个文件，分别是SeqList.h,SeqList.c和main.c文件。下面我们先把结构体定义和各个函数接口实现，最后再把三个文件的代码全部展示出来。

定义结构体

typedef int SLDataType;  // 重新定义数据类型名
typedef struct SeqList
{
    SLDataType* array;  // 定义一个指针，指向开辟出来的数组
    int capacity;  // 顺序表能够容纳的最大元素个数大小，后期可以改变
    int size;  // 有效元素的个数大小
}SeqList;

为什么要重新定义数据类型名？因为顺序表储存的元素类型不单单是int型，后面要存储char型的或者其他类型的数据，需要把代码里面的int都改一遍，非常麻烦。如果我们重新定义了类型名，并且在代码里用重新定义好的名字，下次需要存储其他类型的数据，直接在重定义那里把int改成想存储的类型就好了。

初始化

// 顺序表初始化
void SeqListInit(SeqList* sl)
{
	// 断言，防止传进来的是空指针
	assert(sl != NULL);  // 也可以写成 assert(sl);
	sl->array = NULL;  
	sl->capacity = 0;  
	sl->size = 0;
}

assert是一个断言函数，程序运行的时候，当括号里面的结果为假时，就会停止运行并且报错。报错显示的信息包括断言的内容和断言的位置，还有一个错误框，如下图所示。断言能够快速地帮我们定位程序的错误，在实际开发中可以减少很多不必要的麻烦，所以建议大家在写代码的时候也尽量在需要的时候加上断言。

温馨提示在使用assert函数时，记得包含一下assert.h这个头文件。

在这里插入图片描述

打印

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

检查和增容

// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* sl)
{
	assert(sl);

	// 判断空间是否满了，如果是就增容
	if (sl->capacity == sl->size)
	{
		// 当capacity为0时，赋值为4，不为0时，赋值为capacity的两倍
		int newcapacity = sl->capacity == 0 ? 4 : sl->capacity * 2;

		// 用realloc增容，当sl->array指向NULL时，会像malloc那样去申请空间
		SLDataType* temp = (SLDataType*)realloc(sl->array, sizeof(SLDataType) * newcapacity);
		
		// 判断申请空间是否成功
		assert(temp);

		// 让array指向增容之后的空间地址
		sl->array = temp;
		sl->capacity = newcapacity;
	}
}

在这里插入图片描述

增删查改

头插

在这里插入图片描述

// 顺序表头插
void SeqListPushFront(SeqList* sl, SLDataType x)
{
	assert(sl);

	// 检查空间，不够就增容
	CheckCapacity(sl);

	// 将所有元素往后移一个位置
    int i = 0;
	for (i = sl->size; i > 0; i--)
	{
		sl->array[i] = sl->array[i - 1];
	}

	// 插入数据
	sl->array[0] = x;

	// size加1
	sl->size += 1;

	// 这里空表也适用，所以不用考虑空表
}
尾插

在这里插入图片描述

// 顺序表尾插
void SeqListPushBack(SeqList* sl, SLDataType x)
{
	assert(sl);
	CheckCapacity(sl);
    
    // 插入元素
	sl->array[sl->size] = x;
    
    // size加1
	sl->size += 1;
}
在pos位置插入

在这里插入图片描述

// 顺序表在下标为pos的位置插入x
void SeqListInsert(SeqList* sl, size_t pos, SLDataType x)
{
	assert(sl);
	CheckCapacity(sl);
    
	// 检查pos位置是否有效
	assert(pos >= 0 && pos <= sl->size);

	// 把pos位置开始的所有元素往后移一个位置
	int i = 0;
	for (i = sl->size; i > pos; i--)
	{
		sl->array[i] = sl->array[i - 1];
	}

	// 插入数据
	sl->array[pos] = x;

	// size加一
	sl->size += 1;
}

掌握了在pos位置插入的方法后，前面的头插和尾插也可以写成下面这个样子

// 头插
void SeqListPushFront(SeqList* sl, SLDataType x)
{
	// 调用函数接口插入数据
	SeqListInsert(sl, 0, x);
}

// 尾插
void SeqListPushBack(SeqList* sl, SLDataType x)
{
	SeqListInsert(sl, sl->size, x);
}
头删

在这里插入图片描述

// 顺序表头删
void SeqListPopFront(SeqList* sl)
{
	assert(sl);

	// 判断空表
	assert(sl->size);

	// 把0后面位置的元素都往前移一个位置,即完成头删
	int i = 0;
	for (i = 0; i < sl->size; i++)
	{
		sl->array[i] = sl->array[i + 1];
	}

	// size减1
	sl->size -= 1;
}
尾删

在这里插入图片描述

// 顺序表尾删
void SeqListPopBack(SeqList* sl)
{
	assert(sl);

	// 判断空表
	assert(sl->size);

	// 把size减1即可实现尾删
	sl->size -= 1;
}
删除pos位置的元素

在这里插入图片描述

// 顺序表删除pos位置的值
void SeqListErase(SeqList* sl, int pos)
{
	assert(sl);

	// 判断空表
	assert(sl->size);

	// 判断pos位置是否有效
	assert(pos >= 0 && pos < sl->size);

	// 把pos位置之后的元素都往前移一个位置，即可实现删除
	int i = 0;
	for (i = pos; i < sl->size - 1; i++)
	{
		sl->array[i] = sl->array[i + 1];
	}

	// size减1
	sl->size -= 1;
}

掌握了删除pos位置元素这个方法后，前面的头删和尾删也可以写成下面这个样子

// 头删
void SeqListPopFront(SeqList* sl)
{
	SeqListErase(sl, 0);
}

// 尾删
void SeqListPopBack(SeqList* sl)
{
	SeqListErase(sl, sl->size-1);
}
查找
// 顺序表查找
int SeqListFind(SeqList* sl, SLDataType x)
{
	assert(sl);
	int i = 0;
	for (i = 0; i < sl->size; i++)
	{
		if (sl->array[i] == x)
		{
			// 找到返回下标值
			return i;
		}
	}

	// 找不到返回-1
	return -1;
}
修改
// 顺序表修改
void SeqListModify(SeqList* sl, int pos, SLDataType x)
{
	assert(sl);

	// 判断pos的位置是否有效
	assert(pos >= 0 && pos < sl->size);
	
    // 修改元素
	sl->array[pos] = x;
}

销毁

// 顺序表销毁
void SeqListDestory(SeqList* sl)
{
	assert(sl);

	// 释放申请的空间
	free(sl->array);  // 这里申请的空间是一次性申请一整块的，所以可以一次性释放

	// 指针置空
	sl->array = NULL;

	// 大小和空间置0
	sl->capacity = 0;
	sl->size = 0;
}

SeqList.h文件代码

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


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


// 重新定义数据类型名
typedef int SLDataType;


// 定义结构体
typedef struct SeqList
{
    SLDataType* array;  // 定义一个指针，指向开辟出来的数组
    int capacity;  // 顺序表能够容纳的最大元素个数大小，后期可以改变
    int size;  // 有效元素的个数大小
}SeqList;


// 函数接口

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

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

// 检查和增容
void CheckCapacity(SeqList* sl);

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

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

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

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

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

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

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

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

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

SeqList.c文件代码

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"

// 顺序表初始化
void SeqListInit(SeqList* sl)
{
	
	// 断言，防止传进来空指针
	assert(sl != NULL);  // 也可以写成 assert(sl);
	sl->array = NULL;  
	sl->capacity = 0;  
	sl->size = 0;
}


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


// 检查和增容
void CheckCapacity(SeqList* sl)
{
	assert(sl);

	// 判断空间是否满了，如果是就增容
	if (sl->capacity == sl->size)
	{
		// 当capacity为0时，赋值为4，不为0时，赋值为capacity的两倍
		int newcapacity = sl->capacity == 0 ? 4 : sl->capacity * 2;

		// 用realloc增容，当sl->array指向NULL时，会像malloc那样去申请空间
		SLDataType* temp = (SLDataType*)realloc(sl->array, sizeof(SLDataType) * newcapacity);
		
		// 判断申请空间是否成功
		assert(temp);

		// 让array指向增容之后的空间地址
		sl->array = temp;
		sl->capacity = newcapacity;
	}
}


// 顺序表头插
// 方法一
void SeqListPushFront(SeqList* sl, SLDataType x)
{
	assert(sl);

	// 检查空间，不够就增容
	CheckCapacity(sl);
	
	// 将所有元素往后移一个位置
	int i = 0;
	for (i = sl->size; i > 0; i--)
	{
		sl->array[i] = sl->array[i - 1];
	}

	// 插入数据
	sl->array[0] = x;

	// size加1
	sl->size += 1;

	// 这里空表也适用，所以不用考虑空表
}

// 方法二
//void SeqListPushFront(SeqList* sl, SLDataType x)
//{
//	// 调用函数接口插入数据
//	SeqListInsert(sl, 0, x);
//}


// 顺序表尾插
// 方法一
void SeqListPushBack(SeqList* sl, SLDataType x)
{
	assert(sl);
	CheckCapacity(sl);

	// 插入数据
	sl->array[sl->size] = x;

	// size加一
	sl->size += 1;
}

// 方法二
//void SeqListPushBack(SeqList* sl, SLDataType x)
//{
//	SeqListInsert(sl, sl->size, x);
//}


// 顺序表在pos位置插入x
void SeqListInsert(SeqList* sl, int pos, SLDataType x)
{
	assert(sl);
	CheckCapacity(sl);

	// 检查pos位置是否有效
	assert(pos >= 0 && pos <= sl->size);

	// 把pos位置开始的所有元素往后移一个位置
	int i = 0;
	for (i = sl->size; i > pos; i--)
	{
		sl->array[i] = sl->array[i - 1];
	}

	// 插入数据
	sl->array[pos] = x;

	// size加一
	sl->size += 1;
}


// 顺序表头删
// 方法一
//void SeqListPopFront(SeqList* sl)
//{
//	assert(sl);
//
//	// 判断空表
//	assert(sl->size);
//
//	// 把0后面位置的元素都往前移一个位置,即完成头删
//	int i = 0;
//	for (i = 0; i < sl->size; i++)
//	{
//		sl->array[i] = sl->array[i + 1];
//	}
//
//	// size减1
//	sl->size -= 1;
//}

// 方法二
void SeqListPopFront(SeqList* sl)
{
	SeqListErase(sl, 0);
}


// 顺序表尾删
// 方法一
//void SeqListPopBack(SeqList* sl)
//{
//	assert(sl);
//
//	// 判断空表
//	assert(sl->size);
//
//	// 把size减1即可实现尾删
//	sl->size -= 1;
//}

// 方法二
void SeqListPopBack(SeqList* sl)
{
	SeqListErase(sl, sl->size-1);
}


// 顺序表删除pos位置的值
void SeqListErase(SeqList* sl, int pos)
{
	assert(sl);

	// 判断空表
	assert(sl->size);

	// 判断pos位置是否有效
	assert(pos >= 0 && pos < sl->size);

	// 把pos位置之后的元素都往前移一个位置，即可实现删除
	int i = 0;
	for (i = pos; i < sl->size - 1; i++)
	{
		sl->array[i] = sl->array[i + 1];
	}

	// size减1
	sl->size -= 1;
}

// 顺序表查找
int SeqListFind(SeqList* sl, SLDataType x)
{
	assert(sl);
	int i = 0;
	for (i = 0; i < sl->size; i++)
	{
		if (sl->array[i] == x)
		{
			// 找到返回下标值
			return i;
		}
	}

	// 找不到返回-1
	return -1;
}


// 顺序表修改
void SeqListModify(SeqList* sl, int pos, SLDataType x)
{
	assert(sl);

	// 判断pos的位置是否有效
	assert(pos >= 0 && pos < sl->size);
	
	sl->array[pos] = x;
}


// 顺序表销毁
void SeqListDestory(SeqList* sl)
{
	assert(sl);

	// 释放申请的空间
	free(sl->array);  // 这里申请的空间是一次性申请一整块的，所以可以一次性释放

	// 指针置空
	sl->array = NULL;

	// 大小和空间置0
	sl->capacity = 0;
	sl->size = 0;
}

main.c文件代码

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"

// 测试插入接口
void test1()
{
	// 定义一个结构体变量
	SeqList sl;

	SeqListInit(&sl);
	SeqListPushFront(&sl, 1);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 3);
	SeqListPushFront(&sl, 4);
	SeqListInsert(&sl, 0, 6);
	SeqListPushBack(&sl, 5);

	SeqListPrint(&sl);

	// 销毁顺序表
	SeqListDestory(&sl);
}

// 测试删除接口
void test2()
{
	SeqList sl;

	SeqListInit(&sl);
	SeqListPushFront(&sl, 1);
	SeqListPushFront(&sl, 2);
	//SeqListPopFront(&sl);
	//SeqListPopFront(&sl);
	//SeqListPopFront(&sl);
	SeqListPopBack(&sl);
	SeqListPopBack(&sl);
	SeqListPopBack(&sl);
	//SeqListErase(&sl, 0);
	//SeqListErase(&sl, 1);
	//SeqListErase(&sl, 2);
	SeqListPrint(&sl);

	SeqListDestory(&sl);
}

// 测试查找和修改
void test3()
{
	SeqList sl;

	SeqListInit(&sl);
	SeqListPushFront(&sl, 1);
	SeqListPushFront(&sl, 3);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 3);
	SeqListPushFront(&sl, 4);

	// 一般修改和查找是配合使用的，比如说想把表中的第一个3改为300
	int pos = SeqListFind(&sl, 3);
	SeqListModify(&sl, pos, 300);
	SeqListPrint(&sl);

	SeqListDestory(&sl);
}


int main()
{
	//test1();
	//test2();
	test3();
	return 0;
}

结语

顺序表是我们接触数据结构的第一个需要我们用C语言去实现的内容，刚开始学的时候很多人会觉得比较难，特别是各个函数接口的命名，实在太难记了。很多初学者会自己起一些简单的名字，这也可以，但是不赞成这样做。因为你自己起的名字你看得懂，别人不一定懂，说不定时间久了自己都忘记了。所以建议大家一开始就规范命名，养成良好的习惯。其实这个命名是有规律的，大多数情况是结构体名+功能，使用的是大驼峰命名法（每个单词首字母大写，包括缩写的）。比如上文里的尾插接口SeqListPushBack，可以拆成SeqList+PushBack。另外数据结构的实现，需要熟练掌握C语言的函数，指针，结构体，动态内存规划这些知识。所以建议大家在学习数据结构之前，把C语言的这部分知识学得扎实一点，这样数据结构学起来就轻松很多了。最后，本文是我学完这章内容后的个人总结，要是文章里有什么错误还望各位大神指正。或者对我的文章排版和其他方面有什么建议，也可以在评论区告诉我。如果我的文章对你的学习有帮助，或者觉得写得不错的话记得分享给你的朋友，非常感谢。

点击这里查看下一篇文章–>>数据结构：链表-C语言实现

柿子__
关注
专栏目录
数据结构-顺序表-C语言实现顺序表相关功能-数据结构学习
05-22
C语言实现的数据结构中的顺序表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习 对顺序表边界操作的判定 实现了以下功能： 创建顺序表 向顺序表中插入元素(尾插法，...
顺序表（C语言实现）
trqii_的博客
04-26 5214
顺序表 文章目录顺序表一、**顺序表的基本概念**二、动态顺序表的具体实现1. 顺序表初始化2. 顺序表尾插3. 顺序表头插4. 顺序表尾删5. 顺序表头删6. 顺序表任意位置插入7. 顺序表任意位置删除8. 顺序表查找9. 顺序表修改10. 顺序表打印11. 顺序表销毁三、完整代码 一、顺序表的基本概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表分为以下二类： 1.静态顺序表：使用定长数组存储元素。 #define N
C语言redefinition of ‘xxx‘ 解决以及#ifndef的作用
byhunpo的博客
05-20 1万+
头文件定义报错：error redefinition of 'xxx' typedef struct Str_addr Str_addr; //结构指针地址 struct Str_addr addr_str; typedef struct Str_impact Str_impact; //结构冲击参数 struct Str_impact impact_str; struct Str_addr{ Str_impact *p_impact; ...
数据结构——顺序表（文字+代码+带图详细讲解）
勇气是明知不可为而为之
06-19 2188
从顺序表存储空间中要删除位置 pos的下一个元素位置开始，向前逐个将每个元素向前移动一个位置，直到顺序表存储空间中的所有元素都向前移动了一个位置。从顺序表存储空间中最后一个元素位置开始，向后逐个将每个元素向后移动一个位置，直到顺序表存储空间中的要插入位置 pos 的元素位置。从顺序表存储空间中最后一个元素位置开始，向后逐个将每个元素向后移动一个位置，直到顺序表存储空间中的所有元素都向后移动了一个位置。该函数接受一个指向顺序表结构体的指针 psl 和要插入的元素值 x，并将元素插入到顺序表的末尾。
数据结构案例教程————顺序表（注释解析版）
weixin_73603248的博客
03-30 247
#include<iostream> #include<stdlib.h> #include<string.h> const int MAXSIZE = 100; struct Student{ int no; char name[10]; char sex; int age; char major[12]; }; //这段代码定义了一个顺序表 typedef struct Student ElemType;//E
数据结构--顺序表的c语言实现（超详细注释/实验报告）
热门推荐
池塘春草梦的博客
09-25 1万+
线性表是一种最基本、最常用的数据结构，它有两种存储结构——顺序表和链表。顺序表是由地址连续的的向量实现的，便于实现随机访问。顺序表进行插入和删除运算时，平均需要移动表中大约一半的数据元素，容量难以扩充。
PTA—C语言数据结构：顺序表.ppt
10-11
本文件"PTA—C语言数据结构：顺序表.ppt"是针对PTA（Programming Training Assistant）平台上数据结构课程的一个教学资源，专门探讨了顺序表这一基本数据结构，并提供了相关练习题的解答。下面我们将详细讨论顺序表...
数据结构+顺序表的C语言实现
最新发布
04-24
本工程实现了严蔚敏 《数据结构 C语言》中顺序表的实现以及常用的操作。包括顺序表的初始化、销毁、求表长、查找、查询前驱节点、查询后继节点、插入、删除、遍历、打印等功能。并且写了测试代码，对每个函数都做了...
数据结构-C语言描述（顺序表、链表）
04-01
本次实验的主要目的是让学生通过C语言实现顺序表和链表的相关操作，加深对这两种基本数据结构的理解，并掌握其在实际编程中的应用技巧。 #### 实验目的 1. **顺序表的操作实现**： - `linklistcreat`：创建顺序表...
数据结构顺序表，c语言简单实现
01-12
本文将深入探讨数据结构中的顺序表及其C语言实现。 顺序表，顾名思义，是指元素在内存中按照线性顺序排列的数组。这种结构允许我们通过索引直接访问任何位置的元素，其时间复杂度为O(1)。然而，插入和删除元素时，...
数据结构顺序表的建立
05-08
数据结构c语言编程，关于顺序表的建立，插入，删除，排序等基本操作
[数据结构] - 使用C语言实现顺序表操作
倾城
11-06 988
顺序表 顺序表的抽象数据类型 ADT 线性表（List） Data ElemType *elem; //声明基地址 int length; //线性表中的长度 int maxsize; //线性表最大存储单元 Operation int initSql(sqList *L); //初始化顺序表 int insertElem(sqList *L, int item, ElemType e); //插入元素 int getElem(sqList *L,int ite
数据结构之顺序表（C语言代码及注释）
qq_43965022的博客
09-15 1651
一、顺序表的特点 顺序表存储数据，预先申请一整块足够大的存储空间，然后将数据按照次序逐一存储，数据之间紧密贴合，不留一丝空隙。 优点：在O(1)时间内查找元素；存储密度高。 缺点：扩容不方便；插入和删除元素不方便。 二、代码实现 头文件：SeqList.h #ifndef SEQLIST_H_INCLUDED #define SEQLIST_H_INCLUDED #include <stdio.h> //C语言标准库函数：用于输入和输出的函数、类型和宏。声明文件指针的FILE。常用的
数据结构 第3讲 顺序表
qq_41789959的博客
08-02 670
数据结构 第3讲 顺序表 顺序表是最简单的一种线性结构，逻辑上相邻的数据在计算机内的存储位置也是相邻的，可以快速定位第几个元素，中间不允许有空，所以插入、删除时需要移动大量元素。 顺序表可以分配一段连续的存储空间Maxsize，用elem记录基地址，用length记录实际的元素个数，即顺序表的长度，  结构体的定义：  结构体定义后，如果要定义个顺序表L，就可以写： SqList...
数据结构算法实现-顺序表实现
jiaye_mi的博客
03-08 3368
C++实现数据结构顺序表代码，仅用于学习。
C语言-数据结构-顺序表的创建、插入、删除、销毁
weixin_45925895的博客
08-16 3555
C语言实现数据结构顺序表的创建、添加、删除、销毁
数据结构-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语言版
m0_60773087的博客
11-14 1133
提到顺序表很多人都会想起数组，但真正的顺序表真的只是一个数组那么简单吗？ 再写一个顺序表前，我们需要想三个问题： 1：如何在插入数据时就调整好数字的顺序 2：如何更新数组对的大小 3：数组如何进行扩容 考虑到上面的因素我们知道单靠一个数组是不够的，我们需要一个size记录数组的当前大小，一个capicity记录最大容量 ...
C语言实现数据结构——顺序表
chfens的博客
03-14 2194
C语言实现顺序表的增删查改（严蔚敏C语言第二版）
C语言实现数据结构：顺序表与链表操作
"本次实验是数据结构与算法课程的一部分，主要关注C语言中数据结构的实现，特别是顺序表和链表。学生陈*文在2024年3月31日在实验室B101进行了实验，实验内容包括顺序表和链表的基本操作，如创建、销毁、获取长度、...
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

柿子__

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

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

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

打赏作者

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

抵扣说明：

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

余额充值