【数据结构】使用C语言实现顺序表

已于 2022-05-16 09:49:52 修改
阅读量2.2k 收藏 22
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构
于 2022-04-14 18:24:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a_code_rookie/article/details/124159805
版权

C语言实现顺序表

定义结构体

//结构体
typedef struct {
    int *data;   //动态分配的指针
    int maxsize; //顺序表的最大容量
    int length;  //静态顺序表的当前长度
} SeqList;

此处声明函数

//声明基本操作
void initList(SeqList *L);
void increaseSize(SeqList *L);
int getLength(SeqList L);
int locateElem(SeqList L, int e);
int getElem(SeqList L, int i);
bool insertData(SeqList *L, int i, int e);
bool deleteData(SeqList *L, int i, int *e);
void printList(SeqList L);
bool isEmpty(SeqList L);
void destoryList(SeqList *L);

初始化顺序表。使用 malloc 进行内存的动态分配。

void initList(SeqList *L) {
    L->data = (int *)malloc(INITSIZE * sizeof(int)); // 使用malloc动态分类空间
    L->length = 0;                                   //设置初始长度为0
    L->maxsize = INITSIZE; //设置当前最大容量为初始容量
}

使用 realloc 函数重新分配内存。当插入时溢出调用该方法扩容。

void increaseSize(SeqList *L) {
    printf("即将溢出，进行数组扩容\n");
    int tempSize = L->maxsize;
    L->data = (int *)realloc(L->data, INITSIZE * 2 * sizeof(int));
    L->maxsize = L->maxsize * 2;
    printf("扩容成功，原容量为:%d,扩容后容量为:%d\n", tempSize, L->maxsize);
}

获取当前表的长度。

int getLength(SeqList L) {
    printf("当前表的最大容量：%d\n", L.maxsize);
    return L.length;
}

查找值为 e 的位序。注意位序从 1 开始而不是 0。

int locateElem(SeqList L, int e) {
    for (int i = 0; i < L.length; i++) {
        if (L.data[i] == e) {
            return i + 1;
        }
    }
    return 0;
}

查找位序为 i 的值。

int getElem(SeqList L, int i) {
    if (i < 1 || i > L.length) { //查找的元素位序不合法
        printf("查找的元素位序不合法！\n");
        return 0;
    } else {
        return L.data[i - 1];
    }
}

在第 i 个位序中插入元素 e。

bool insertData(SeqList *L, int i, int e) {
    if (i < 1 || i > L->length + 1) { //插入位置不合法
        return false;
    } else if (L->length == L->maxsize) { //容量已满，扩容
        increaseSize(L);
    }
    for (int j = L->length; j >= i; j--) { //将第j-1个元素的值赋值给第j个元素
        L->data[j] = L->data[j - 1];
    }
    L->data[i - 1] = e; //将e赋值给第i-1个元素
    L->length++;        //当前长度+1
    return true;
}

删除第 i 个位序的值。

bool deleteData(SeqList *L, int i, int *e) {
    if (i < 1 || i > L->length + 1) { //位置不合法
        return false;
    } else {
        *e = L->data[i - 1];
        printf("将被删除的值为:%d\n", *e);
        for (int j = i; j < L->length; j++) { //将后一个元素的值赋值给前一个元素
            L->data[j - 1] = L->data[j];
        }
        L->length--;
        return true;
    }
}

判断表是否为空。

bool isEmpty(SeqList L) { return L.length == 0; }

销毁表，释放空间。

void destoryList(SeqList *L) {
    free(L->data);
    L->length = 0;
    L->maxsize = 0;
}

遍历顺序表，打印输出。

void printList(SeqList L) {
    printf("打印当前表\n");
    for (int i = 0; i < L.length; i++) {
        printf("L.data[%d]=%d\n", i, L.data[i]);
    }
}

测试结果

在这里插入图片描述
在这里插入图片描述

完整代码

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#define INITSIZE 10 //定义初始容量

//结构体数组
typedef struct {
    int *data;   //动态分配的指针
    int maxsize; //顺序表的最大容量
    int length;  //静态顺序表的当前长度
} SeqList;

//声明基本操作
void initList(SeqList *L);
void increaseSize(SeqList *L);
int getLength(SeqList L);
int locateElem(SeqList L, int e);
int getElem(SeqList L, int i);
bool insertData(SeqList *L, int i, int e);
bool deleteData(SeqList *L, int i, int *e);
void printList(SeqList L);
bool isEmpty(SeqList L);
void destoryList(SeqList *L);

/*
初始化顺序表
*/
void initList(SeqList *L) {
    L->data = (int *)malloc(INITSIZE * sizeof(int)); // 使用malloc动态分类空间
    L->length = 0;                                   //设置初始长度为0
    L->maxsize = INITSIZE; //设置当前最大容量为初始容量
}

/*
增加动态数组长度，默认扩容为原来的两倍
*/
void increaseSize(SeqList *L) {
    printf("即将溢出，进行数组扩容\n");
    int tempSize = L->maxsize;
    L->data = (int *)realloc(L->data, INITSIZE * 2 * sizeof(int));
    L->maxsize = L->maxsize * 2;
    printf("扩容成功，原容量为:%d,扩容后容量为:%d\n", tempSize, L->maxsize);
}

/*
获取当前表的长度
*/
int getLength(SeqList L) {
    printf("当前表的最大容量：%d\n", L.maxsize);
    return L.length;
}

/*
查找值为e的元素的位序
如果能够找到，返回该元素的位置，否则返回0。
*/
int locateElem(SeqList L, int e) {
    for (int i = 0; i < L.length; i++) {
        if (L.data[i] == e) {
            return i + 1;
        }
    }
    return 0;
}

/*
获取第i个元素的值
*/
int getElem(SeqList L, int i) {
    if (i < 1 || i > L.length) { //查找的元素位序不合法
        printf("查找的元素位序不合法！\n");
        return 0;
    } else {
        return L.data[i - 1];
    }
}

/*
在第i个位置插入元素e
*/
bool insertData(SeqList *L, int i, int e) {
    if (i < 1 || i > L->length + 1) { //插入位置不合法
        return false;
    } else if (L->length == L->maxsize) { //容量已满，扩容
        increaseSize(L);
    }
    for (int j = L->length; j >= i; j--) { //将第j-1个元素的值赋值给第j个元素
        L->data[j] = L->data[j - 1];
    }
    L->data[i - 1] = e; //将e赋值给第i-1个元素
    L->length++;        //当前长度+1
    return true;
}

/*
删除表第i个位序的值。如果删除成功则返回true并存入e。
删除失败则返回false
*/
bool deleteData(SeqList *L, int i, int *e) {
    if (i < 1 || i > L->length + 1) { //位置不合法
        return false;
    } else {
        *e = L->data[i - 1];
        printf("将被删除的值为:%d\n", *e);
        for (int j = i; j < L->length; j++) { //将后一个元素的值赋值给前一个元素
            L->data[j - 1] = L->data[j];
        }
        L->length--;
        return true;
    }
}

/*
判断表是否为空
*/
bool isEmpty(SeqList L) { return L.length == 0; }

/*
释放表的空间，销毁表
*/
void destoryList(SeqList *L) {
    free(L->data);
    L->length = 0;
    L->maxsize = 0;
}

/*
遍历顺序表，打印输出
*/
void printList(SeqList L) {
    printf("打印当前表\n");
    for (int i = 0; i < L.length; i++) {
        printf("L.data[%d]=%d\n", i, L.data[i]);
    }
}

int main(int argc, char const *argv[]) {
    SeqList L;
    printf("初始化当前顺序表...\n");
    initList(&L);
    if (isEmpty(L)) {
        printf("该表为空!\n");
    } else {
        printf("该表非空!\n");
    }
    printf("当前表的长度：%d\n", getLength(L));
    int num;
    printf("插入元素个数为:");
    scanf("%d", &num);
    for (int i = 0; i < num; i++) {
        insertData(&L, i + 1, i);
    }
    printList(L);
    printf("当前表的长度：%d\n", getLength(L));
    int e;
    printf("输入要获取位序的数:");
    scanf("%d", &e);
    printf("值为%d的位序为:%d\n", e, locateElem(L, e));
    int i;
    printf("输入位序:");
    scanf("%d", &i);
    printf("位序为%d的值为:%d\n", i, getElem(L, i));
    int *delNum, delLocal;
    printf("输入要删除位序的值:");
    scanf("%d", &delLocal);
    bool flag = deleteData(&L, delLocal, delNum);
    if (flag) {
        printf("第%d个位序被删除，删除的值为:%d\n", delLocal, *delNum);
        printf("当前表的长度：%d\n", getLength(L));
    } else {
        printf("输入的位序不合法，删除失败！\n");
    }
    printList(L);
    printf("销毁该表！\n");
    destoryList(&L);

    return 0;
}
每天进步一点丶
关注
  • 3
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
顺序表的基本操作
weixin_64084604的博客
11-18 1667
顺序表的基本操作
【数据结构】C语言实现顺序表
weixin_44104992的博客
07-26 3420
C语言实现顺序表
顺序表的代码实现
m0_73592835的博客
12-15 911
顺序表的代码实现
【数据结构】C语言实现顺序表（超级详细）
热门推荐
m0_74459723的博客
01-01 1万+
顺序表作为线性表的一种，它是用一段数据元素的线性结构，一般情况下采用。在数组上完成数据的增删查改。顺序表一般分为：1、静态顺序表——使用定长数组进行存储元素。这种存储方式在存储数据时比较有局限性，当数据存储量非常小的时候，数组长度太长，会造成空间的浪费；当数据存储量非常大的时候，数组空间可能会不够，但是这种存储方式不能进行扩容。所以在实现顺序表时，我们通常使用的是动态顺序表。这样能够提高我们的空间利用率。2、动态顺序表——使用动态开辟的数组进行存储元素。
58653213456798452
m0_68081211的博客
04-03 64
#include<stdio.h> #include<stdlib.h> #define InitSize 100 typedef struct { //定义一个名为Sqlist的结构体 int *data; int MaxSize; int length; } Sqlist; //初始化顺序表 void InitList(Sqlist *L) { L->data = (int*)malloc(Init...
【数据结构实现】C语言实现顺序表
03-06
本次试验用C语言实现顺序表，实现 Init 初始化线性表 Destory 销毁线性表 Clear 清空线性表 IsEmpty 判断线性表是否为空 Length 获取线性表的长度 GetElem 获取线性表中某个元素的值 Locate 在线性表中查找指定元素 ...
数据结构顺序表 C语言代码实现以及realloc的使用
07-09
本文将深入探讨如何使用C语言实现顺序表，并重点讲解`realloc`函数在扩展内存时的作用。 首先，我们需要理解顺序表的基本操作，包括创建、插入、删除和查找。在C语言中，我们可以使用结构体来表示顺序表，例如定义...
数据结构+顺序表的C语言实现
最新发布
04-24
本工程实现了严蔚敏 《数据结构 C语言》中顺序表的实现以及常用的操作。包括顺序表的初始化、销毁、求表长、查找、查询前驱节点、查询后继节点、插入、删除、遍历、打印等功能。并且写了测试代码，对每个函数都做了...
c语言数据结构顺序表合并
12-01
1.建立两个顺序表（通过随机函数生成）； 2.排序（升序），输出合并前的结果； 3.对这两个顺序表进行合并（保持升序）； 4.输出合并结果
数据结构顺序表，c语言简单实现
01-12
本文将深入探讨数据结构中的顺序表及其C语言实现。 顺序表，顾名思义，是指元素在内存中按照线性顺序排列的数组。这种结构允许我们通过索引直接访问任何位置的元素，其时间复杂度为O(1)。然而，插入和删除元素时，...
顺序表的创建以及其他基本操作
cat_like_ice的博客
03-19 70
顺序表的创建以及其他基本操作，有学习参考
简单顺序表实现
行走江湖的少侠哥
06-14 462
#include #include #define MAX_LENGTH 20 typedef struct { char name[20]; double price; }BOOK; typedef struct { BOOK *list; int length; }Sqlist; int InitList(Sqlist *); //初始化顺序表 void PrintLis
顺序表的插入删除打印
qq_51029996的博客
06-13 500
顺序表的插入删除以及打印
【C语言14】C语言实现顺序表（这可能是CSDN有史以来讲解最详细的顺序表)
南喵的博客
07-18 1001
顺序表什么是顺序表官方定义：顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中**顺序表和数组同样是连续的空间数组必须提前开辟好空间，而顺序表可以随开随用。
【数据结构】超详细之顺序表（利用C语言实现）
m0_74088266的博客
05-01 2076
数据结构是一个程序员必须会的一种操作功能，学习数据结构能提高我们的逻辑思维能力以及解决实际项目能力，数据结构分为很多种，今天我们要讲的是数据结构中的顺序表.提示：以下是本篇文章正文内容，下面案例可供参考。
数据结构-顺序表基本操作的实现
weixin_45770392的博客
08-19 678
今天是线性表中的顺序表的实现，主要实现函数如下，读者有需要可以评论，我可以适当加几个。 //实现数组的以下操作，并编写程序验证你的操作。 int InputList(SeqList *L,int n); //输入n个整数存放到数组中 int PrintList(SeqList *L); //输出数组中的所有元素 int Locate(SeqList *L,ElemType e); //在数组L中查找e,返回找到
c语言实现顺序表
dong132697的博客
08-20 262
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。顺序表可以实现随机访问，即通过下标就可以访问元素。顺序表的中间/头部的插入删除，时间复杂度为O(N)。顺序表增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。顺序表增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
顺序栈（最简便打印栈中元素）
qq_17807067的博客
04-01 4605
最好记，最好理解的打印栈模板，个人感觉已经是最好了，如有更好请评论~
【 数据结构 】顺序表的实现 - 详解（C语言版）
上上谦. 的博客
03-13 8039
目录 前言 线性表： ​ 顺序表： 概念及结构： 顺序表的实现： 头文件：SeqList.h realloc函数讲解： 具体函数的实现：SeqList.c 顺序表的初始化： 顺序表的打印： 容量的检查： 顺序表的尾插： 顺序表的尾删： 顺序表的头插： 顺序表的头删： 在顺序表的指定位置插入数据： 在顺序表的指定位置删除数据： 顺序表的查找： 顺序表的修改： 顺序表的销毁： 数组越界的检查： 前言 简单用C语言来描述数据结构中的顺序表......
数据结构c语言实现顺序表创建
06-03
以下是C语言实现顺序表创建的示例代码： ``` #include #include #define MAXSIZE 100 // 定义顺序表的最大长度 typedef struct { int data[MAXSIZE]; // 存储顺序表元素的数组 int length; // 记录顺序表当前...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

每天进步一点丶

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

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

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

打赏作者

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

抵扣说明：

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

余额充值