【数据结构】使用C语言 从零编写一个顺序表

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

前言

在学习完C语言的所有语法之后，会发现C语言的数组的功能其实没有那么强大，它仅仅能够存储特定类型、特定数量的元素，不能够扩容，也不能够插入或者删除某一个元素，所以这样的数据结构其实并不够强大，如果能够实现一个能够完成这几个操作的数据结构就好了。本篇博客将会把数组衍生，使用结构体、指针等知识，构建一个顺序表。

顺序表的定义

线性表是由同一类型的数据元素构成的有序序列的线性结构。线性表中元素的个数就是线性表的长度，表的起始位置称为表头，表的结束位置称为表尾，当一个线性表中没有元素时，称为空表。

线性表一般具有的功能

  • 初始化： 我们可以初始化从而得到一个线性表。
  • 获取指定位置上的元素： 直接获取线性表指定位置上的元素。
  • 获取元素的位置： 获取某个元素在线性表上的位置。
  • 插入元素： 在指定位置上插入一个元素。
  • 删除元素： 删除指定位置上的一个元素。
  • 获取长度： 返回线性表的长度。

定义一个新的数据结构体

由于我们需要设计一个新的数据结构，所以我们提前定义一个该数据结构的结构体。假设该结构体存储的类型是int，把int型起个别名E，如果以后需要存别的类型，就把这个E修改就可以了。

typedef int E;

struct List
{
    E array[10];
    int capacity;
};

这里通过struct声明了一个结构体，其中包括一个E类型的数组，capacity表示该数组的容量。

通过该结构体，我们可以编写一个函数用于初始化数组，当我们声明一个List类型的变量的时候，把变量本身作为参数传入初始化函数就能够对其初始化：

void initList(struct List list)
{
    list.capacity = 10;
}

但是我们会发现，这样的函数传进来的变量只是一个局部变量，当函数结束之后内存就会被销毁，所以这样子的初始化函数是有问题的。

最好的方法应该是传入一个List类型变量的指针，然后通过指针初始化变量的值，我们可以把List类型变量的指针改个名：

typedef struct List * ArrayList;

void initList(ArrayList list)
{
    list->capacity = 10;
}

然后通过指针传参，这样就能成功初始化了。

#include <stdio.h>


typedef int E;

struct List
{
    E array[10];
    int capacity;
};

typedef struct List * ArrayList;

void initList(ArrayList list)
{
    list->capacity = 10;
}

int main()
{
    struct List list;

    printf("初始化前：%d\n",list.capacity);//初始化前：0

    initList(&list);

    printf("初始化后：%d\n",list.capacity);//初始化后：10

    return 0;
}

代码到此，我们定义了一个线性表类型，并让该类型默认拥有10个长度的数组和一个capacity属性，并且编写了一个初始化函数用于初始化该类型中的数据。（好想说属性，学面向对象学的…）

现在想想，把里面数组的长度写死为10不太好，不够自由，我们可以使用malloc函数指定该数组使用多少内存空间，如果要这样写的话，List结构体中就不能直接声明数组了，而是声明一个指向数组的指针。

#include <stdio.h>
#include <stdlib.h>

typedef int E;

struct List
{
    E * array;
    int capacity;
};

typedef struct List * ArrayList;

void initList(ArrayList list)
{
    list->array = malloc(sizeof (E) * 10);
    list->capacity = 10;
}

储存线性表的元素个数

我们一般在结构体中定义一个size来储存元素个数，默认初始化为0,同时我们再完善一下初始化函数，如果申请内存空间失败，则返回0（false）。

struct List
{
    E * array;
    int capacity;
    int size;
};

typedef struct List * ArrayList;

int initList(ArrayList list)
{
    list->array = malloc(sizeof (E) * 10);
    if (list->array == NULL) return 0;
    
    list->capacity = 10;
    list->size = 0;
    
    return 1;
}

当我们执行初始化操作的时候，可以用if判断是否初始化成功：

	struct List list;
    if (initList(&list)){
        ...
    } else
    {
        printf("初始化线性表失败！");
    }

实现插入元素的操作

首先定义一个函数，用于实现对线性表的插入操作。

该函数需要传入表的地址，需要插入的元素，还有插入的位置。

void insertList(ArrayList list,E element,int index)

注意：index和索引不一样，index没有0，从1开始

插入操作大概可以分为三部分

  • 找到需要插入的位置，从该位置开始，将之后的元素全部往后移动一个单位
  • 在需要插入的位置，修改为指定的元素
  • 插入完毕后，增加size的值
void insertList(ArrayList list,E element,int index)
{
    for (int i = list->size;i > index-1;i--)
    {
        list->array[i] = list->array[i-1];
    }

    list->array[index-1] = element;
    list->size++;
}

可以写一个打印表的函数来测试一下效果：

#include <stdio.h>
#include <stdlib.h>

typedef int E;

struct List
{
    E * array;
    int capacity;
    int size;
};

typedef struct List * ArrayList;

int initList(ArrayList list)
{
    list->array = malloc(sizeof (E) * 10);
    if (list->array == NULL) return 0;

    list->capacity = 10;
    list->size = 0;

    return 1;
}

void insertList(ArrayList list,E element,int index)
{
    for (int i = list->size;i > index-1;i--)
    {
        list->array[i] = list->array[i-1];
    }

    list->array[index-1] = element;
    list->size++;
}

void printList(ArrayList list){
    for (int i = 0; i < list->size; ++i)
        printf("%d ", list->array[i]);
    printf("\n");
}

int main()
{
    struct List list;

    if (initList(&list)){
        insertList(&list, 111, 1);
        printList(&list);
        insertList(&list, 222, 1);
        printList(&list);
        insertList(&list, 333, 2);
        printList(&list);
    } else
    {
        printf("初始化线性表失败！");
    }
    
    return 0;
}

输出结果为：

111
222 111
222 333 111

说明，表的插入操作成功。

但在上述代码中，没有考虑到别的情况，比如说如果插入一个非法的位置 如-1，表中没有这个位置便会插入失败；比如，如果插入的元素过多，多到了超过了先前定义的40个字节的内存大小，程序的内存就会不安全，所以做扩容的操作也是有必要的。

解决插入到非法位置的问题

解决这个问题可以通过size属性判断，如果要插入的位置在[0,size+1]的区间内，就可以插入，如果不在则不能返回，在函数中便返回0；只需要在循环之前加一个判断。

int insertList(ArrayList list,E element,int index)
{
    if (index < 0 || index > list->size+1) return 0;
    for (int i = list->size;i > index-1;i--)
    {
        list->array[i] = list->array[i-1];
    }

    list->array[index-1] = element;
    list->size++;
    
    return -1;
}

解决内存扩容的问题

如果要解决这个问题，需要在插入数组之前进行一次判断，如果表中的元素个数等于表的容量，则把该表之前申请的内存空间大小进行增加，生成新的内存，生成新内存之后，还要把历史元素重新添加进新申请的内存中。

在C语言中，可以不用这么麻烦，我们可以使用realloc函数轻松完成这个任务。

realloc函数可以做到控制动态内存开辟的大小，重新申请的内存空间大小就是我们指定的新的大小，并且原有的数据也会放到新申请的空间中，所以非常方便。当然如果因为内存不足之类的原因导致内存空间申请失败，那么会返回NULL，所以别忘了进行判断。

int insertList(ArrayList list,E element,int index)
{
    if (index < 0 || index > list->size+1) return 0;

    if (list->size == list->capacity)
    {
        int newCapacity = list->capacity *= 2;// 更新新的容量
        E * newArray = realloc(list->array,sizeof (E) * newCapacity);// 内存扩容
        if (newCapacity == NULL) return 0;
        list->array = newArray;
        list->capacity = newCapacity;
    }

    for (int i = list->size;i > index-1;i--)
    {
        list->array[i] = list->array[i-1];
    }

    list->array[index-1] = element;
    list->size++;

    return -1;
}

这样就完善了表的插入操作，我们可以测试一下：

int main()
{
    struct List list;
    if(initList(&list)){
        for (int i = 0; i < 30; ++i)
            insertList(&list, i, i+1);
        printList(&list);
    } else{
        printf("顺序表初始化失败，无法启动程序！");
    }

    return 0;
}

输出结果：

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

实现删除元素的操作

实现这个过程，思路和插入差不多，只不过需要删除的位置的区间在[1,size]内。

int deleteList(ArrayList list, int index)

删除元素分为两步：

  • 找到需要删除元素的位置将该位置往后的所有元素往前移
  • 将表的size减1

实现获取长度、按位置获取元素、查找元素

int sizeList(ArrayList list) // 获取表长度
{
    return list->size;
}

E * getList(ArrayList list, int index) // 按位置获取元素地址
{
    if (index < 1 || index > list->size) return NULL;
    return &(list->array[index-1]);
}

void printList(ArrayList list){
    for (int i = 0; i < list->size; ++i)
        printf("%d ", list->array[i]);
    printf("\n");
}

int findList(ArrayList list,E element) // 查找元素
{
    for (int i = 0;i < list->size;i++)
    {
        if (list->array[i] == element) return i + 1;
    }
    
    return -1;
}

实现完成

代码写到此，以数组为基底，构建一个线性表就结束了，一下是全部代码：

#include <stdio.h>
#include <stdlib.h>

/*
* 初始化： 我们可以初始化从而得到一个全新的线性表。
* 获取指定位置上的元素： 直接获取线性表指定位置上的元素。
* 获取元素的位置： 获取某个元素在线性表上的位置。
* 插入元素： 在指定位置上插入一个元素。
* 删除元素： 删除指定位置上的一个元素。
* 获取长度： 返回线性表的长度。
 */
typedef int E;

struct List
{
    E * array;
    int capacity;
    int size;
};

typedef struct List * ArrayList;

int initList(ArrayList list)
{
    list->array = malloc(sizeof (E) * 10);
    if (list->array == NULL) return 0;

    list->capacity = 10;
    list->size = 0;

    return 1;
}

int insertList(ArrayList list,E element,int index)
{
    if (index < 0 || index > list->size+1) return 0;

    if (list->size == list->capacity)
    {
        int newCapacity = list->capacity *= 2;// 更新新的容量
        E * newArray = realloc(list->array,sizeof (E) * newCapacity);// 内存扩容
        if (newCapacity == NULL) return 0;
        list->array = newArray;
        list->capacity = newCapacity;
    }

    for (int i = list->size;i > index-1;i--)
    {
        list->array[i] = list->array[i-1];
    }

    list->array[index-1] = element;
    list->size++;

    return -1;
}

int deleteList(ArrayList list, int index)
{
    if (index < 1 || index > list->size) return 0;
    for (int i = index-1;i < list->size - 1;i++)
    {
        list->array[i] = list->array[i+1];
    }
    list->size--;

    return 1;
}

int sizeList(ArrayList list) // 获取表长度
{
    return list->size;
}

E * getList(ArrayList list, int index) // 按位置获取元素地址
{
    if (index < 1 || index > list->size) return NULL;
    return &(list->array[index-1]);
}

void printList(ArrayList list){
    for (int i = 0; i < list->size; ++i)
        printf("%d ", list->array[i]);
    printf("\n");
}

int findList(ArrayList list,E element) // 查找元素
{
    for (int i = 0;i < list->size;i++)
    {
        if (list->array[i] == element) return i + 1;
    }

    return -1;
}

int main()
{
    struct List list;
    if(initList(&list)){
        for (int i = 0; i < 30; ++i)
            insertList(&list, i, i+1);
        printList(&list);
    } else{
        printf("顺序表初始化失败，无法启动程序！");
    }

    return 0;
}
冲鸭嘟嘟可
关注
  • 26
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
数据结构 用C语言来创建一个顺序表
lovemingshu的博客
06-17 2万+
顺序表的创建需要用到结构体，构造一个结构体来存储数据，顺序表申请的内存是连续的。创建顺序表的思路按照数据的“增删改查来进行编写”下列是顺序表的创建代码 创建头文件： sqlist.h #ifndef SQLIST_H #define SQLIST_H #define N 100 #define ming 1119 #define shu 1120 typedef int T; typedef st...
数据结构C语言完成顺序表基本操作
04-25
顺序表是由数组支持的数据结构，每个元素都有一个固定的索引位置。在C语言中，我们通常使用动态数组来实现顺序表，因为它允许在运行时改变数组的大小。 2. **C语言基础**： 在C语言中，我们可以使用`malloc()`和`...
数据结构——顺序表（C语言编写）
新手小白
09-17 7877
数据结构，顺序表应用 插入、删除、合并...
【数据结构】C语言实现顺序表
weixin_44104992的博客
07-26 3412
C语言实现顺序表
C语言结构体文件链表实例
4-5月更新计算机程序设计的一些实例，之后再更新计算机基础，机器智能相关的一些内容。
04-14 377
int num;int card;int n;i < n;i++){exit(1);top = p;rear = p;else{rear = p;FILE * fp;i < n;i++){getchar();fclose(fp);return 0;
数据结构 （一）顺序表 附完整代码 C语言实现
m0_73451522的博客
06-04 748
采用顺序储存结构的线性表叫做顺序表。线性表的顺序储存是用一组地址连续的储存单元依次储存线性表中的各个元素，使得线性表中在逻辑结构上相邻的数据元素储存在相邻的物理储存单元中即通过数据元素物理储存的相邻性来反映数据元素之间逻辑上的相邻关系。线性表是n个类型相同的数据元素的有限序列，对n>0，除第一元素无直接前驱和最后一个元素无直接后继外，其余的每个数据元素只有一个直接前驱和一个直接后继。
C语言 实现顺序表合并（数据结构）
m0_54158068的博客
04-08 3837
C语言实现顺序表合并（数据结构）
(数据结构C语言版)顺序表和单链表的逆置.docx
07-07
在C语言中，顺序表和单链表的逆置操作可以通过编写相应的程序来实现。例如，对于顺序表，程序可以首先初始化顺序表，然后插入元素，最后进行逆置操作。对于单链表，程序可以首先创建单链表，然后插入元素，最后进行...
C语言 数据结构 顺序表的操作.doc
04-08
（6）编写顺序表L的判空函数int ListEmpty(List L)和求顺序表长度的函数int ListLength(List L)。 （7）编写函数int ListLocate(ListItem x,List L)，判断x位置。 （8）输入主函数对上面各个函数实现调用，并记录...
数据结构 - 顺序表(Contiguous-List)
10-23
**数据结构 - 顺序表(Contiguous-List)** 顺序表是数据结构中的一种基本类型，它是线性表的一种具体实现方式。在计算机科学中，数据结构的选择与操作直接影响到程序的效率和性能。理解并掌握顺序表的概念、特点以及...
数据结构静态顺序表.zip
02-03
在这个“数据结构静态顺序表.zip”压缩包中，包含的是作者用C语言实现的静态顺序表源代码。 首先，让我们深入理解静态顺序表的概念。静态顺序表是一种固定大小的数组，其长度在创建时就已经确定，且在表的整个生命...
数据结构--二叉树和堆
binhyun的博客
07-07 830
1.基本概念 2.树的遍历方法 3.满二叉树&&完全二叉树 4.逻辑结构&&物理结构 5.推理公式 6.二叉树应用--堆 7.简单实现堆
[数据结构] 基于插入的排序 插入排序&希尔排序
水墨不写bug
07-06 1140
插入排序&&希尔排序 实现原理
D1.排序
2302_79232710的博客
07-07 180
快速排序和归并排序
数据结构之链表
2301_80772499的博客
07-07 527
链表的结构，是否带头，是否循环，是否双向六中结构讲解，以及链表的用途,缺点
6、Redis系统-数据结构-03-压缩列表
qq_29434541的博客
07-07 1598
由于压缩列表需要进行空间扩展操作，这就需要重新分配内存，因此连锁更新一旦发生，会导致压缩列表占用的内存空间多次重新分配，直接影响到压缩列表的访问性能。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。而当新插入的元素较大时，可能会导致后续元素的。
数据结构之顺序表
m0_73634434的博客
07-10 318
线性表(List)由零个或多个数据组成的有限数列，线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列，字符串。
【排序 - 堆排序】
最新发布
2302_80393814的博客
07-10 271
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
数据结构--单链表实现
LH__1314的博客
07-05 1395
链表和顺序表都是线性表的一种，但是顺序表在物理结构和逻辑结构上都是连续的，但链表在逻辑结构上是连续的，而在物理结构上不一定连续；来看以下图片来认识链表与顺序表的差别这里以动态顺序表为例，和链表中的单链表对比一下动态顺序表单链表这里就可以很清晰的看到顺序表的底层其实就是一个数组，数据的是连续存储的（顺序表物理结构连续）；而链表它每一个数据都不是连续的（链表物理结构上不一定连续）。链表节点通过观察上图，我们会发现链表每一个节点都存放在数据和下一个节点的地址。
数据结构实验指导书C语言版
05-11
在C语言中，顺序表的存储结构通常定义为一个结构体，包含一个数组来存储元素和一个整型变量来记录表的长度。例如，可以定义如下： ```c #define MAXLEN 30 /* 线性表的最大长度 */ typedef struct { Elemtype elem...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

冲鸭嘟嘟可

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

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

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

打赏作者

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

抵扣说明：

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

余额充值