动态顺序表的实现

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

文章目录

动态顺序表的实现

实现动态顺序表的代码多种多样，不过大体思路一致，我们提供一个思路，重在理解，才会做题，才能看懂其他的形式。

  • 我们将代码分为三个文件实现，分别为：

SeqList.h: 包含所有需要的头文件，定义以及接口函数的声明。

SeqList: 保存所有接口函数的定义和实现

test.c: 主函数,一般为打印菜单，调用接口函数，需求多样，我们仅实现头文件和接口函数。

头文件

由于我们要实现的是动态顺序表，所以存储数据的位置是我们开辟的动态内存空间。我们先编辑SeqList.h

//SeqList.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SQDateType;//未来如果想在顺序表中存储其他类型的数据，仅需要修改int为想存储的类型
typedef struct SeqList
{
	SQDateType* a;//指向存储数据的内存空间
	int size;//顺序表中的有效数据的个数
	int capacity;//顺序表的容量，也就是最大存储数据数
}SL;

接口函数实现

完成以上准备，我们可以开始准备我们的接口函数了，实现对顺序表的增删查改等操作。

  • 首先，对我们的顺序表进行初始化：

    void SeqListInit(SL* ps)
{
    ps->a = NULL;
    ps->size = 0;
    ps->capacity = 0;
}

  • 实现一个打印顺序表的函数

    void SeqListPrint(SL* ps)
{
    for(int i = 0; i < ps->size; i++)
    {
        printf("%d ",ps->a[i]);//注意，我们在修改存储数据的类型时，同时需要修改这里的占位符
    }
    printf("\n");
}

  • 我们继续分析，每次在顺序表中插入数据，我们都需要判断容量是否占满，如果占满，我们需要对我们的内存空间进行扩容。

    考虑到频繁实现这样的操作，我们专门将这一操作分装成一个独立的函数，每次插入数据时，调用这个函数即可，省去了重复书写的麻烦。

    void SeqListCheckCapacity(SL* ps)
{
    if(ps->size == ps->capacity)//只有空间满，才需要扩容
    {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        //确定新容量，一般扩容为原来的两倍，别忘了考虑容量为0时的情况（证明没有开辟过空间），这种情况下肯定是没有办法存储数据的，同时扩容后的效果为：0 * 2 = 0，相当于没有扩容。所以我们先判断容量是否为0，为0，那么我们给容量赋一个合理的数值，作为新容量（这里我们赋值4）；否则，我们将容量扩大一倍，这种逻辑刚好可以用三目操作符实现。
        SQDateType* tmp = (SQDateType*)realloc(ps->a, newcapacity * sizeof(SQDateType));
        //我们创建一个新的指针变量来接收realloc的返回值，避免了开辟失败后返回NULL覆盖原有地址的情况。
        if(tmp == NULL)//判断如果为NULL，则打印错误信息并退出函数。
        {
            printf("realloc fail!\n");
            exit(-1);
        }
        else//不为空，证明开辟（扩容）成功。
        {
            ps->capacity = newcapacity;
            ps->a = tmp;
        }
    }
}

  • 好了，我们可以尝试实现一个尾插的接口函数了。

    void SeqListPushBack(SL* ps, SQDateType x)
{
    SeqListCheckCapacity(ps);//尾插需要插入新数据，调用SeqListCheckCapacity函数
    ps->a[ps->size] = x;
    ps->size++;//插入后及时更新有效数据的个数
}

  • 头插函数

    void SeqListPushFront(SL* ps, SQDateType x)
{
    //思路：将所有元素向后移动一位，再将新元素插入到表首
    SeqListCheckCapacity(ps);
    for(int i = ps->size; i >= 1; i--)
    {
        ps->a[i] = ps->[i-1];
    }
    ps->a[0] = x;
    ps->size++;
}

  • 尾删函数

    void SeqListPopBack(SL* ps)
{
    ps->a[ps->size-1] = 0;//这句语句可以省略，因为我们打印顺序表时是以size为基准的，size--再打印不会显示最后一个元素，而如果再在那个位置插入时就直接覆盖掉了
    ps->size--;
}

  • 头删函数

    void SeqListPopFront(SL* ps)
{
    //思路:从第二个数据开始依次向左移动一位，将头数据覆盖
    for(int i = 0; i < ps->size; i++)
    {
        ps->a[i] = ps->a[i+1];
    }
    ps->size--;
}

  • 插入函数

    void SeqListInsert(SL* ps, int pos, SQDateType x)
{
    //这里的pos以及后面出现的pos不是下标，而是位置，例如下标为0的元素的位置为1
    //思路：将pos位置（即下标为pos-1的元素的位置）及之后的所有元素向后移动一位，再将新元素放在指定的位置。
    assert(pos < ps->size);//如果插入位置参数输入非法，则报错
    SeqListCheckCapacity(ps);
    for(int i = ps->size; i > pos - 1; i--)
    {
        ps->a[i] = ps->a[i-1];
    }
    ps->a[pos-1] = x;
    ps->size++;
}

  • 删除函数

    void SeqListErase(SL* ps, int pos)
{
    //思路：将pos位置后面的所有元素向前移动一位，覆盖掉pos位置的元素
    assert(pos < ps->size);
    for(int i = pos - 1; i < ps->size; i++)
    {
        ps->a[i] = ps->a[i+1];
    }
    ps->size--;
}

  • 查找函数

    int SeqListFind(SL* ps, SQDateType x)
{
    //思路：遍历即可
    for(int i = 0; i < ps->size; i++)
    {
        if(ps->a[i] == x)
        {
            return i;
        }
    }
    return -1;
}

  • 修改函数

    void SeqListModity(SL* ps, int pos, SQDateType x)
{
    //思路:找到指定位置后直接修改即可
    assert(pos < ps->size);
    ps->a[pos-1] = x;
}

  • 释放函数

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

至此我们完成了我们的接口函数定义实现部分，接口函数当然不止这些，不过这里也涵盖了最常见的接口函数，理解了这些，其他接口函数的实现也就如鱼得水。

完整代码

//SeqList.h

#pragma once
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <assert.h>
typedef int SQDateType;
typedef struct SeqList
{
	SQDateType* a;
	int size;
	int capacity;
}SL;


void SeqListInit(SL* ps);
void SeqListPrint(SL* ps);
void SeqListCheckCapacity(SL* ps);

void SeqListPushBack(SL* ps, SQDateType x);
void SeqListPushFront(SL* ps, SQDateType x);
void SeqListPopBack(SL* ps);
void SeqListPopFront(SL* ps);
void SeqListInsert(SL* ps, int pos, SQDateType x);
void SeqListErase(SL* ps, int pos);
void SeqListModity(SL* ps, int pos, SQDateType x);
int SeqListFind(SL* ps, SQDateType x);
void SeqListDestory(SL* ps);


//SeqList.c

#include "SeqList.h"
void SeqListInit(SL* ps)
{
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}


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


void SeqListCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SQDateType* tmp = (SQDateType*)realloc(ps->a, newcapacity * sizeof(SQDateType));
		if (tmp == NULL)
		{
			printf("%s\n", strerror(errno));
			exit(-1);
		}
		else
		{
			ps->capacity = newcapacity;
			ps->a = tmp;
		}
	}
}


void SeqListPushBack(SL* ps, SQDateType x)
{
	SeqListCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}


void SeqListPushFront(SL* ps, SQDateType x)
{
	SeqListCheckCapacity(ps);
	for (int i = ps->size; i >= 1; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[0] = x;
	ps->size++;
}


void SeqListPopBack(SL* ps)
{
	ps->a[ps->size - 1] = 0;
	ps->size--;
}


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


void SeqListInsert(SL* ps, int pos, SQDateType x)
{
	assert(pos < ps->size);
	SeqListCheckCapacity(ps);
	for (int i = ps->size; i > pos - 1; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[pos - 1] = x;
	ps->size++;
}


void SeqListErase(SL* ps, int pos)
{
	assert(pos < ps->size);
	for (int i = pos - 1; i < ps->size; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}


int SeqListFind(SL* ps, SQDateType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}


void SeqListModity(SL* ps, int pos, SQDateType x)
{
	assert(pos < ps->size);
	ps->a[pos - 1] = x;
}


void SeqListDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}
四角小裤儿儿
关注
  • 17
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言实现动态顺序表
ljx_5489464的博客
03-14 2255
1、用于存放声明的头文件#pragma once //避免重复引入头文件，作用于预编译指令几乎相同#define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <assert.h> #include <malloc.h>typedef int DataType; typedef struct SepList_d { DataTy
C++实现动态顺序表
08-19
"C++实现动态顺序表" C++中实现动态顺序表是指使用C++语言来实现一个可以动态变化的顺序表结构。这种结构可以根据需要动态地分配和释放内存，从而提高程序的效率和灵活性。 在C++中，使用动态顺序表可以通过使用...
C语言实验-动态顺序表实现简易通讯录
wyd_333的博客
10-08 5081
C语言数据结构顺序表的应用：简易通讯录
动态顺序表的C语言实现（详细）
qq_983030560的博客
11-28 2115
顺序表的C语言实现
动态顺序表(C语言)
学代码的咸鱼的博客
03-28 2845
轻松带你搞定顺序表！
【线性表】—动态顺序表的增删查改实现
热门推荐
诺诺的包包
11-27 1万+
线性表—动态顺序表的完整实现，用动态图演示与代码相结合，更容易理解！
动态通讯录（用顺序表实现）
晶凌玄夜的博客
04-13 1658
利用顺序表实现动态通讯录，实质就是一个动态顺序表，基本代码和顺序表大致 相同，涉及到结构体的创建，初始化，插入，删除，查找等功能。 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<assert.h> #include<string.h> //定...
【数据结构】顺序表专题--＞动态顺序表实现详解！(附:全部码源)
Gao123456fy的博客
04-27 1239
【数据结构】顺序表专题-->动态顺序表实现详解！(附:全部码源)
动态顺序表（C语言实现）
cw412524的博客
11-13 764
数据结构动态顺序表（C语言实现），干货满满！
【数据结构】顺序表实现超详解（保姆级教程）
~
10-15 2174
目录 ​ 前言 顺序表 接口实现 各项功能 接口详解 顺序表初始化 顺序表释放 顺序表展示 顺序表容量检查 顺序表数据尾插 顺序表数据头插 顺序表数据前删 顺序表数据尾删 顺序表数据查找 顺序表指定位置插入数据 顺序表指定位置删除数据 前言 本章主要讲解： 顺序表以及顺序表的接口实现 注：保姆级教程，相信你一定会的~ 顺序表 顺序表是线性标的一种 概念： 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储...
C语言实现动态顺序表的实现代码
12-31
C语言实现动态顺序表的实现代码 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点...
C++实现动态顺序表（vector）
08-19
C++实现动态顺序表（vector） C++中的动态顺序表（vector）是一种非常重要的数据结构，它可以自动调整大小以适应不断变化的数据量。下面是对C++实现动态顺序表的详细介绍。 动态顺序表的定义 动态顺序表是一种...
函数模板与类模板
程序员_小兵
07-12 1553
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
36. Adam 算法详解
qq_41238579的博客
07-10 972
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
基于Big-Bang-Big-Crunch(BBBC)算法的目标函数最小值计算matlab仿真
熟悉python,matlab,C,C++,JAVA等
07-12 374
BBBC算法的核心思想模拟了宇宙从大爆炸（Big Bang）开始，经历扩张，再到可能的大收缩（Big Crunch）的过程，以此类比于在解空间中从初始分散的解集出发，通过一系列搜索过程逐步集中并接近最优解的过程。：一个简化的聚集方法可以是xi′′​=xbest​+β⋅(xi′​−xbest​)，其中xbest​是最优解，β是一个小于1的收缩因子，控制收缩速度。：每个解xi​依据一定的规则在解空间中移动，这个移动可以是随机的，也可以基于某种策略，比如基于目标函数梯度的方向或者利用当前解与其他解的相对位置。
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 361
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 762
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
树与二叉树
最新发布
2201_76027754的博客
07-15 449
树和二叉树
c语言二叉树排序算法动态顺序表实现
05-10
接下来，我们可以定义一个创建二叉树的函数，该函数可以接收一个动态顺序表作为输入，并返回二叉树的根节点。 ```c Node* createBinaryTree(int* arr, int size) { Node* root = NULL; for (int i = 0; i ; i++) ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值