【C语言数据结构】1.顺序表

已于 2022-04-18 20:43:28 修改
阅读量1.1k 收藏 2
点赞数 1
分类专栏： # 数据结构（C语言版） 文章标签： 开发语言 C语言 数据结构
于 2022-04-18 16:05:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43129713/article/details/124244476
版权

目录

一、顺序表的结构定义

二、顺序表的结构操作

1.初始化

2.插入操作

3.删除操作 

4.扩容操作 

5.释放操作

6.输出

三、示例

        编程环境为 ubuntu 18.04。 

        顺序表需要连续一片存储空间，存储任意类型的元素，这里以存储 int 类型数据为例。

一、顺序表的结构定义

        size 为容量，length 为当前已知数据表元素的个数

typedef struct Vector{
    int *data;  //该顺序表这片连续空间的首地址
    int size, length;
} Vec;

二、顺序表的结构操作

1.初始化

Vec *init(int n){    //该顺序表具有n个存储单元
    Vec *v = (Vec *)malloc(sizeof(Vec));  //在内存栈上开辟一个空间  malloc在内存的堆区，在函数外面也能访问
    v->data = (int *)malloc(sizeof(int) * n);
    v->size = n;
    v->length = 0;
    return v;
}

2.插入操作

int insert(Vec *v, int ind, int val) {       //ind为插入元素的位置,val为插入元素的值
    if(v == NULL) return 0;
    if(ind < 0 || ind > v->length) return 0;    //判断要插入的位置是否合法
    if(v->length == v->size) {    
        if(!expand(v)){    //扩容失败
            printf(RED("fail to expand!\n"));
        }
        printf(GREEN("success to expand! the size = %d\n"),v->size);
    }
    for(int i = v->length; i > ind; i--){
        v->data[i] = v->data[i-1];
    }
    v->data[ind] = val;
    v->length += 1;
    return 1;
}
  •   为什么需要判断插入的位置是否合法呢？这是因为顺序表是连续一片存储空间，所以内存是连续的。

        下图以 length = 5，size = 9 为例，我们只能在下标为 0 到 4 之间的数中插入数据。

  •  插入一个元素示意图

3.删除操作 

int erase(Vec *v, int ind){    //把下标为ind的元素删除
    if(v == NULL) return 0;
    if(ind < 0 || ind >= v->length) return 0;
    for(int i = ind + 1; i < v->length; i++){
        v->data[i - 1] = v->data[i];
    }
    v->length -= 1;
    return 1;
}
  • 判断需要删除元素的下标是否合法，与插入元素类似
  •  删除一个元素示意图

4.扩容操作 

int expand(Vec *v){
    //顺序表的扩容
    //malloc 动态申请空间，空间不一定干净  calloc 动态申请空间，并且清空  realloc 重新申请空间
    int extr_size = v->size;
    int *p;
    while(extr_size) {
        p = (int *)realloc(v->data, sizeof(int) * (v->size + extr_size));
        if(p != NULL) break;   //p不为空，说明扩容成功，这个时候直接跳出循环
        extr_size >>= 1;    //否则就把额外扩容的空间除以2，降低要求
    }
    if(p == NULL) return 0; //判断跳出循环究竟是扩容成功还是扩容失败，如果扩容失败，那就是p为空地址，找不到符合条件的内存区域
    v->size += extr_size;
    v->data = p;
    return 1;
}

         注意扩容这里写的比较巧妙，首先 int extr_size = v->size; 表示先将需要扩容的大小设置成原本的大小，然后就判断能不能找到那么大的空间。  p = (int *)realloc(v->data, sizeof(int) * (v->size + extr_size));  如果在系统中能找到这么大的容量，那么就返回找到的内存地址的首地址，然后就可以结束跳出循环；要是找不到的话那只能降低要求，把 extr_size 除以 2，看看能不能知道，如果实在找不到，extr_size 为 0，就会跳出循环。然后可以通过判断 p 是不是空指针来判断程序是找到能够扩容的空间退出的还是找不到退出的。

        要是对 malloc、calloc 和 realloc 不熟悉的，可以看我这篇博文：【C语言进阶剖析】37.C语言中的动态内存分配

5.释放操作

void clear(Vec *v){  //释放空间
    if(v == NULL) return;
    free(v->data);
    free(v);
    return;
}

        先释放数据，再释放整个顺序表。 

6.输出

void output(Vec *v){
    if(v == NULL) return ;
    printf("[");
    for(int i = 0; i < v->length; i++){
        i && printf(", ");
        printf("%d", v->data[i]);
    }
    printf("]\n");
    return ;
}

三、示例

#include <stdio.h>
#include<stdlib.h>
#include<time.h>
//#include<windows.h>


#define COLOR(a, b) "\033[" #b "m" a "\033[0m"


#define GREEN(a) COLOR(a, 32)
#define RED(a) COLOR(a, 31)


typedef struct Vector{
    int *data;  //该顺序表这片连续空间的首地址
    int size, length;
} Vec;


Vec *init(int n){    //该顺序表具有n个存储单元
    Vec *v = (Vec *)malloc(sizeof(Vec));  //在内存栈上开辟一个空间  malloc在内存的堆区，在函数外面也能访问
    v->data = (int *)malloc(sizeof(int) * n);
    v->size = n;
    v->length = 0;
    return v;
}


int expand(Vec *v){
    //顺序表的扩容
    //malloc 动态申请空间，空间不一定干净  calloc 动态申请空间，并且清空  realloc 重新申请空间
    int extr_size = v->size;
    int *p;
    while(extr_size) {
        p = (int *)realloc(v->data, sizeof(int) * (v->size + extr_size));
        if(p != NULL) break;   //p不为空，说明扩容成功，这个时候直接跳出循环
        extr_size >>= 1;    //否则就把额外扩容的空间除以2，降低要求
    }
    if(p == NULL) return 0; //判断跳出循环究竟是扩容成功还是扩容失败，如果扩容失败，那就是p为空地址，找不到符合条件的内存区域
    v->size += extr_size;
    v->data = p;
    return 1;
}


int insert(Vec *v, int ind, int val) {       //ind为插入元素的位置,val为插入元素的值
    if(v == NULL) return 0;
    if(ind < 0 || ind > v->length) return 0;
    if(v->length == v->size) {
        if(!expand(v)){
            printf(RED("fail to expand!\n"));
        }
        printf(GREEN("success to expand! the size = %d\n"),v->size);
    }
    for(int i = v->length; i > ind; i--){
        v->data[i] = v->data[i-1];
    }
    v->data[ind] = val;
    v->length += 1;
    return 1;
}


int erase(Vec *v, int ind){    //把下标为ind的元素删除
    if(v == NULL) return 0;
    if(ind < 0 || ind >= v->length) return 0;
    for(int i = ind + 1; i < v->length; i++){
        v->data[i - 1] = v->data[i];
    }
    v->length -= 1;
    return 1;
}


void output(Vec *v){
    if(v == NULL) return ;
    printf("[");
    for(int i = 0; i < v->length; i++){
        i && printf(", ");
        printf("%d", v->data[i]);
    }
    printf("]\n");
    return ;
}


void clear(Vec *v){  //释放空间
    if(v == NULL) return;
    free(v->data);
    free(v);
    return;
}


int main(){
    #define MAX_N 20
    Vec *v = init(1);
    srand(time(0));  //设置种子
    for (int i = 0; i < MAX_N; i++){
        int op = rand() % 4;
        int ind = rand() % (v->length + 3) - 1; //取值范围[-1, v->length + 1]
        int val = rand() % 100;  //val为1到99之间的数
        switch(op){
            case 0:
            case 1:
            case 2: {
                printf("insert %d at %d to the Vector = %d\n", val, ind, insert(v, ind, val));
            }break;
            case 3:{
                printf("erase a item at %d = %d\n",ind,erase(v, ind));
            }break;
        }
        output(v);
        printf("\n");
    }
    #undef MAX_N
    clear(v);
    return 0;
}

        输出结果如下：

insert 82 at 0 to the Vector = 1
[82]

insert 38 at 2 to the Vector = 0
[82]

success to expand! the size = 2
insert 7 at 1 to the Vector = 1
[82, 7]

success to expand! the size = 4
insert 86 at 2 to the Vector = 1
[82, 7, 86]

erase a item at 4 = 0
[82, 7, 86]

erase a item at 4 = 0
[82, 7, 86]

insert 48 at 0 to the Vector = 1
[48, 82, 7, 86]

insert 65 at 5 to the Vector = 0
[48, 82, 7, 86]

success to expand! the size = 8
insert 92 at 4 to the Vector = 1
[48, 82, 7, 86, 92]

erase a item at 2 = 1
[48, 82, 86, 92]

insert 81 at 2 to the Vector = 1
[48, 82, 81, 86, 92]

insert 9 at 0 to the Vector = 1
[9, 48, 82, 81, 86, 92]

insert 99 at 1 to the Vector = 1
[9, 99, 48, 82, 81, 86, 92]

insert 29 at 7 to the Vector = 1
[9, 99, 48, 82, 81, 86, 92, 29]

success to expand! the size = 16
insert 38 at 0 to the Vector = 1
[38, 9, 99, 48, 82, 81, 86, 92, 29]

erase a item at 0 = 1
[9, 99, 48, 82, 81, 86, 92, 29]

erase a item at 8 = 0
[9, 99, 48, 82, 81, 86, 92, 29]

erase a item at 6 = 1
[9, 99, 48, 82, 81, 86, 29]

insert 57 at -1 to the Vector = 0
[9, 99, 48, 82, 81, 86, 29]

insert 32 at 4 to the Vector = 1
[9, 99, 48, 82, 32, 81, 86, 29]
清风自在 流水潺潺
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
c语言数据结构顺序表合并
12-01
1.建立两个顺序表（通过随机函数生成）； 2.排序（升序），输出合并前的结果； 3.对这两个顺序表进行合并（保持升序）； 4.输出合并结果
数据结构初阶——顺序表
weixin_45138295的博客
10-30 239
本文讲述了数据结构最基础的内容线性表——动态顺序表的实现。
数据结构之顺序表
北川_的博客
08-24 1489
一级目录 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素，这种表示也称作线性表的顺序存储结构或顺序映像。通常，称这种存储结构的线性表为顺序表（Sequential List）。其特点是，逻辑上相邻的数据元素，其物理次序也是相邻的。 ...
数据结构初级——顺序表
weixin_53937197的博客
09-08 628
今天我们就是进入数据结构初阶的学习。我们采用C语言实现数据结构，以多文件形式写代码 目录 <一>顺序表的定义 <二>顺序表的结构体定义 <三>顺序表创建 <四>给顺序表尾插一个数据 <五>顺序表头部删除 <六>顺序表的尾部删除 <七>顺序表的头部删除 <八>顺序表的指定位置插入 <九>指定位置删除 <一>顺序表的定义 顺序表是在计算机内存中以数组的形式保存的线性表，
PTA—C语言数据结构：顺序表.ppt
10-11
PTA平台数据结构课程顺序表参考答案
数据结构之线性表
qq_43607916的博客
10-05 278
线性表 文章目录： 线性表的定义 线性表的基本操作 顺序表的定义 顺序表的两种实现方式 顺序表的基本操作 其他笔记的总结 3.顺序表的定义 4.顺序表的两种实现方式 静态分配 动态分配 5.顺序表的基本操作 插入 删除 按位查找 按值查找 6.其他笔记的总结 以上是顺序表的内容，之后会更新单链表的相关知识内容。 ...
PTA 6-4 查找元素(*)
wcd278212784的博客
03-31 1946
6-4 查找元素(*)添加链接描述 已知顺序表的结构定义如下： typedef struct { int size, length; int *element; } ALIST; 说明：element 为存储数据元素的动态数组的起始地址，size 为动态数组的尺寸，length 为顺序表的长度。 请编写函数，在顺序表中查找数据元素。 函数原型 int AListFind(const ALIST *list, int element); 说明：参数 list 为指示线性表(顺序表)的指针，element 为待
数据结构（c语言版）之顺序表
u012882633的专栏
11-18 847
#include #include #define LIST_INIT_SIZE  100 //线性顺序表空间的初始大小 #define INCREMENT_SIZE 10       //线性顺序表空间不够时增加的大小 typedef struct{ int *elem; //顺序表基址 int length; //顺序表长度 int listsize;  
王道数据结构2.2.1-顺序表的定义
Aurora_zxj的博客
08-06 1022
1、顺序表的实现——静态分配 #include<iostream> using namespace std; #define MaxSize 10 //定义最大长度 typedef struct{ int data[MaxSize]; //用静态数组存放数据元素 int length;//顺序表的当前长度 }SqList; //顺序表的类型定义 //初始化一个顺序表 void InitList(SqList &L){ for(int i=0;i<MaxSiz
C语言数据结构顺序表 学生表 学生成绩管理系统.zip
06-25
C语言数据结构学生成绩管理系统
C语言 数据结构 顺序表的操作.doc
04-08
（1）根据下列程序环境的设置，完成顺序表的初始化函数List ListInit(int size)的编写。typedef int ListItem; /* 表元素类型 int */ （2）在第（1）题的基础上，void ListInsert(int k,ListItem x,List L)，实现在...
c语言 数据结构实验二 顺序表的应用
05-31
数据结构实验
开发语言漫谈-SQL
wangbing1125的博客
04-21 617
坏消息是SQL有很多方言，每个数据库系统都有或多或少的扩展，各个数据库之间有很多细微的差距。这个困惑类似做Javascript的怎么兼容各浏览器，编写SQL的得考虑怎么做数据库兼容。SQL是另一个门类的开发语言，是专用于结构化数据库操作的专用语言。SQL不可能单独开发系统，但是做数据库方面的系统不懂SQL也不行。市面上很大部分开发岗位（后台）都是要和数据库打交道的，所以SQL必须掌握。目前流行的趋势是这些逻辑由服务程序处理，数据库只做单纯的存储。做管理系统维护和服务的同学，SQL是必备技能。
互联网大厂ssp面经，数据结构part3
最新发布
qq_41214208的博客
04-24 1204
互联网大厂ssp面经，数据结构part2
【数据结构】单链表
GGDxianv的博客
04-21 1001
单链表和顺序表一样都是属于数据结构中的一部分，下面来总结和实现单链表。
【数据结构】树和二叉树（Tree）
2201_75475240的博客
04-21 1136
本文章介绍数据结构中的树的基本知识，包括二叉树的表示和实现、树和森林的转换以及遍历规律，且还包含408习题（附有解析）。此外，含有关于二叉树的二叉链表全部具体实现代码。
【数据结构】排序
qq_44768318的博客
04-22 910
在数组中选取三个候选元素（通常为数组的首、尾、中点元素），并将这三个候选元素的中位数作为。执行哨兵划分 partition() 【完全有序的输入数组在每次划分时占用栈帧空间大】遍历整个数组，保持左侧的始终是排序好的数组，将当前元素插入到左侧对应的位置。与冒泡排序的区别是：冒泡在每个内循环都会交换，而选择只会在外循环交换。分治思想：将两个或多个已经有序的序列合并成一个。在待排序元素中选取最小（最大）的元素加入序列。【解决输入数组是完全倒序的最差情况】进行多次的、间隔的插入排序。先划分【中点处】后合并。
浅识数据结构之时间复杂度
LiU11e的博客
04-21 973
时间复杂度的简单概括
c语言数据结构如何清空顺序表
03-31
1. 将顺序表的长度设置为0，即将表中元素个数清零。 2. 如果需要释放内存，则可以使用free函数释放表中元素占用的内存空间，代码如下： ```c free(list->data); list->data = NULL; ``` 其中，list是指向顺序表的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

清风自在 流水潺潺

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

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

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

打赏作者

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

抵扣说明：

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

余额充值