c语言顺序线性表的实现

已于 2023-03-01 22:06:34 修改
阅读量839 收藏 11
点赞数 1
文章标签： c语言 数据结构 Powered by 金山文档
于 2023-03-01 17:39:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pakai/article/details/129285796
版权

结构体的定义

//顺序线性表的结构体
typedef struct List {
    ElemType * dataList;  //数据地址
    int listLength;  //数据表长度
    int listSize; //当前分配的存储容量
}List;

状态码的定义

#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量
#define LISTINCREMENT 10 //线性表存储空间的分配增量
#define ElemType int //自定义数据类型

typedef int Status; //定义状态码类型

#define OK 1 //完成
#define OVERFLOW 0 //失败
#define ERROR 0 //错误

初始化

//初始化
Status InitList(List* L) {
    L->dataList = (ElemType*)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if (!L->dataList) {
        printf("初始化失败！\n");
        exit(OVERFLOW);  //终止函数，exit(0)代表正常退出，exit(1)/exit(-1)代表异常退出
    }
    L->listLength = 0;
    L->listSize = LIST_INIT_SIZE;
    printf("初始化成功！\n");
    return OK;
}

表尾插入新元素

//表尾插入新元素
void ListPushBack(List* L, ElemType e) {
    if (L->listLength >= L->listSize) {  //当前存储空间已满，增加分配
        int* newbase = (ElemType*)realloc(L->dataList, (L->listSize + LISTINCREMENT) * sizeof(ElemType));
        /*
        * malloc函数是对没有分配过的内存块直接进行分配，需要使用free（）来释放内存块
        * realloc函数是对已经分配好的内存块重新进行分配，不需要使用free（）来释放内存块
        */
        if (!newbase) exit(OVERFLOW);
        L->dataList = newbase;
        L->listSize += LISTINCREMENT;
    }
    L->dataList[L->listLength] = e;
    L->listLength++;
    printf("元素%d已经添加至表尾\n",e);
}

删除

//删除第i个元素
Status ListDelete(List* L, int i) {
    //在顺序表中删除第i个元素
    if (i<1 || i > L->listLength) //i值不合法
        return ERROR;
    int p = L->listLength;
    int q ;
    for (i; i <= p; i++) {
        q = i - 1;
        L->dataList[q] = L->dataList[i];
    }
    L->listLength--;
    printf("删除成功\n");
    return OK;
}

插入

//在第i个位置插入一个新元素e
Status ListInsert(List* L, int i, ElemType e) {
    //i的合法值是1<=i<=listLength
    if (i<1 || i > L->listLength) {  //i值不合法
        printf("i值不合法\n");
        return ERROR;
    }
    if (L->listLength >= L->listSize) {  //当前存储空间已满，增加分配
        int* newbase = (ElemType*)realloc(L->dataList, (L->listSize + LISTINCREMENT) * sizeof(ElemType));
        /*
        * malloc函数是对没有分配过的内存块直接进行分配，需要使用free（）来释放内存块
        * realloc函数是对已经分配好的内存块重新进行分配，不需要使用free（）来释放内存块
        */
        if (!newbase) exit(OVERFLOW);
        L->dataList = newbase;
        L->listSize += LISTINCREMENT;
    }
    ElemType *q;
    q= &(L->dataList[i - 1]);  //插入位置
    ElemType* p;
    for (p = &(L->dataList[L->listLength - 1]); p >= q; --p) { //插入位置及以后的元素后移
        *(p + 1) = *p;
    }
    *q = e;
    L->listLength++;
    printf("已成功插入值\n");
    return OK;
}

在顺序表中查找第一个与e相匹配的值

//在顺序表中查找第一个与e相匹配的值
Status LocateElem(List* L, ElemType e) {
    int i = 0;
    ElemType *p;
    p = L->dataList;
    while (i<L->listLength && p[i]!=e)//&& !compare(*p++,e)
    {
        i++;
    }
    if (i < L->listLength) {
        printf("与%d相匹配的第一个序号是%d\n", e, i+1);
        return i;
    }
    else
    {
        printf("未匹配\n");
        return 0;
    }
}

打印顺序表

//顺序打印顺序表
Status ListPrint(List* L) {
    for (int i = 0; i < L->listLength; i++) {
        printf("%d\t", L->dataList[i]);
    }
    printf("\n");
    return OK;
}

合并顺序表

//顺序表的合并
void MergeList(List La, List Lb, List *Lc) {
    //已知顺序线性表La和Lb按非递减排序
    //归并La和Lb到Lc，并按非递减排序
    ElemType *pa,*pb,*pc;
    pa = La.dataList;
    pb = Lb.dataList;
    Lc->listSize = Lc->listLength = La.listLength + Lb.listLength;
    pc = Lc->dataList = (ElemType*)malloc(Lc->listSize * sizeof(ElemType));
    if (!Lc->dataList) {
        exit(OVERFLOW);
    }
    int* pa_last, * pb_last;
    pa_last = La.dataList + La.listLength - 1;
    pb_last = Lb.dataList + Lb.listLength - 1;
    while (pa<=pa_last&&pb<=pb_last)
    {
        if (*pa <= *pb) {
            *pc++ = *pa++;
        }
        else {
            *pc++ = *pb++;
        }
    }
    while (pa<=pa_last)
    {
        *pc++ = *pa++;
    }
    while (pb<=pb_last)
    {
        *pc++ = *pb++;
    }
}

完整代码

#include <stdio.h>
#include<stdlib.h>
#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量
#define LISTINCREMENT 10 //线性表存储空间的分配增量
#define ElemType int //自定义数据类型

typedef int Status; //定义状态码类型

#define OK 1 //完成
#define OVERFLOW 0 //失败
#define ERROR 0 //错误

//顺序线性表的结构体
typedef struct List {
    ElemType * dataList;  //数据地址
    int listLength;  //数据表长度
    int listSize; //当前分配的存储容量
}List;

//初始化
Status InitList(List* L) {
    L->dataList = (ElemType*)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if (!L->dataList) {
        printf("初始化失败！\n");
        exit(OVERFLOW);  //终止函数，exit(0)代表正常退出，exit(1)/exit(-1)代表异常退出
    }
    L->listLength = 0;
    L->listSize = LIST_INIT_SIZE;
    printf("初始化成功！\n");
    return OK;
}

//在第i个位置插入一个新元素e
Status ListInsert(List* L, int i, ElemType e) {
    //i的合法值是1<=i<=listLength
    if (i<1 || i > L->listLength) {  //i值不合法
        printf("i值不合法\n");
        return ERROR;
    }
    if (L->listLength >= L->listSize) {  //当前存储空间已满，增加分配
        int* newbase = (ElemType*)realloc(L->dataList, (L->listSize + LISTINCREMENT) * sizeof(ElemType));
        /*
        * malloc函数是对没有分配过的内存块直接进行分配，需要使用free（）来释放内存块
        * realloc函数是对已经分配好的内存块重新进行分配，不需要使用free（）来释放内存块
        */
        if (!newbase) exit(OVERFLOW);
        L->dataList = newbase;
        L->listSize += LISTINCREMENT;
    }
    ElemType *q;
    q= &(L->dataList[i - 1]);  //插入位置
    ElemType* p;
    for (p = &(L->dataList[L->listLength - 1]); p >= q; --p) { //插入位置及以后的元素后移
        *(p + 1) = *p;
    }
    *q = e;
    L->listLength++;
    printf("已成功插入值\n");
    return OK;
}

//删除第i个元素
Status ListDelete(List* L, int i) {
    //在顺序表中删除第i个元素
    if (i<1 || i > L->listLength) //i值不合法
        return ERROR;
    int p = L->listLength;
    int q ;
    for (i; i <= p; i++) {
        q = i - 1;
        L->dataList[q] = L->dataList[i];
    }
    L->listLength--;
    printf("删除成功\n");
    return OK;
}

//在顺序表中查找第一个与e相匹配的值
Status LocateElem(List* L, ElemType e) {
    int i = 0;
    ElemType *p;
    p = L->dataList;
    while (i<L->listLength && p[i]!=e)//&& !compare(*p++,e)
    {
        i++;
    }
    if (i < L->listLength) {
        printf("与%d相匹配的第一个序号是%d\n", e, i+1);
        return i;
    }
    else
    {
        printf("未匹配\n");
        return 0;
    }
}

//顺序打印顺序表
Status ListPrint(List* L) {
    for (int i = 0; i < L->listLength; i++) {
        printf("%d\t", L->dataList[i]);
    }
    printf("\n");
    return OK;
}

//表尾插入新元素
void ListPushBack(List* L, ElemType e) {
    if (L->listLength >= L->listSize) {  //当前存储空间已满，增加分配
        int* newbase = (ElemType*)realloc(L->dataList, (L->listSize + LISTINCREMENT) * sizeof(ElemType));
        /*
        * malloc函数是对没有分配过的内存块直接进行分配，需要使用free（）来释放内存块
        * realloc函数是对已经分配好的内存块重新进行分配，不需要使用free（）来释放内存块
        */
        if (!newbase) exit(OVERFLOW);
        L->dataList = newbase;
        L->listSize += LISTINCREMENT;
    }
    L->dataList[L->listLength] = e;
    L->listLength++;
    printf("元素%d已经添加至表尾\n",e);
}

//顺序表的合并
void MergeList(List La, List Lb, List *Lc) {
    //已知顺序线性表La和Lb按非递减排序
    //归并La和Lb到Lc，并按非递减排序
    ElemType *pa,*pb,*pc;
    pa = La.dataList;
    pb = Lb.dataList;
    Lc->listSize = Lc->listLength = La.listLength + Lb.listLength;
    pc = Lc->dataList = (ElemType*)malloc(Lc->listSize * sizeof(ElemType));
    if (!Lc->dataList) {
        exit(OVERFLOW);
    }
    int* pa_last, * pb_last;
    pa_last = La.dataList + La.listLength - 1;
    pb_last = Lb.dataList + Lb.listLength - 1;
    while (pa<=pa_last&&pb<=pb_last)
    {
        if (*pa <= *pb) {
            *pc++ = *pa++;
        }
        else {
            *pc++ = *pb++;
        }
    }
    while (pa<=pa_last)
    {
        *pc++ = *pa++;
    }
    while (pb<=pb_last)
    {
        *pc++ = *pb++;
    }
}

void main() {
    List L;
    InitList(&L);
    ListPushBack(&L, 1);
    ListPushBack(&L, 2);
    ListPushBack(&L, 3);
    ListPushBack(&L, 4);
    ListPushBack(&L, 5);
    ListPushBack(&L, 6);
    ListPushBack(&L, 7);
    ListPrint(&L);
    ListInsert(&L, 1, 1);
    ListInsert(&L, 3, 2);
    ListInsert(&L, 9, 7);
    ListPrint(&L);
    ListDelete(&L, 3);
    ListPrint(&L);
    LocateElem(&L, 6 );
}

运行结果

合并顺序表演示

void main() {
    List La;
    List Lb;
    List Lc;
    InitList(&La);
    ListPushBack(&La, 1);
    ListPushBack(&La, 2);
    ListPushBack(&La, 3);
    ListPushBack(&La, 4);
    ListPushBack(&La, 5);
    ListPushBack(&La, 6);
    ListPushBack(&La, 7);
    ListPrint(&La);
    InitList(&Lb);
    ListPushBack(&Lb, 2);
    ListPushBack(&Lb, 4);
    ListPushBack(&Lb, 6);
    ListPushBack(&Lb, 8);
    ListPushBack(&Lb, 10);
    ListPrint(&Lb);
    MergeList(La, Lb, &Lc);
    ListPrint(&Lc);
}

pakai
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言实现的顺序线性表
01-16
本篇文章将深入探讨如何使用C语言来实现顺序线性表，包括其基本操作，如创建、插入数据、获取数据、删除数据、获取存放的数据量、清空线性表以及销毁线性表。 顺序线性表是由一组具有相同类型元素构成的序列，这些...
if (!S.base)exit(OVERFLOW)是什么意思
weixin_45963815的博客
04-11 1万+
在学习数据结构栈这一部分的时候，有一句代码 if (!S.base)exit(OVERFLOW)； 搞不懂什么意思 exit是c++程序的退出函数，声明为void exit(int value) 其功能是退出当前的程序，并将参数value返回主调进程 OVERFLOW为math.h的一个宏定义，其值为3。含义为运算过程中出现了上溢，即运算结果超出了运算变量所能存储的范围。 所以，exit(OVER...
C语言中的exit()函数
热门推荐
春卷同学的博客
03-09 8万+
函数名: exit() 所在头文件：stdlib.h 功 能: 关闭所有文件，终止正在执行的进程。 exit(1)表示异常退出.这个1是返回给操作系统的。 exit(x)（x不为0）都表示异常退出 exit(0)表示正常退出 exit()的参数会被传递给一些操作系统，包括UNIX,Linux,和MS DOS，以供其他程序使用。stdlib.h: void exit(int status); 参 数...
exit的用法
yyy_zxc的博客
09-12 4327
exit用于在程序运行的过程中随时结束程序，exit的参数是返回给OS的。exit是结束一个进程，它将删除进程使用的内存空间，同时把错误信息返回父进程,而return是返回函数值并退出函数。所以，exit(OVERFLOW)的含义就是，退出程序，并返回OVERFLOW的值给主调进程。其标准的使用范围为，当程序运算出现上溢时，退出程序并报错给主调进程。原文链接：https://blog.csdn.net/weixin_45963815/article/details/105455178。
exit在c语言里的作用,C语言中exit函数的使用
weixin_29011239的博客
05-16 1万+
exit() 结束当前进程/当前程序/，在整个程序中，只要调用 exit ，就结束return() 是当前函数返回，当然如果是在主函数main, 自然也就结束当前进程了，如果不是，那就是退回上一层调用。在多个进程时.如果有时要检测上进程是否正常退出的.就要用到上个进程的返回值..exit(1)表示进程正常退出. 返回 1;exit(0)表示进程非正常退出. 返回 0.进程环境与进程控制(1): 进...
数据结构（C语言版）第三章 栈和队列-整理-队列
Glitter_N的博客
11-19 152
队列 允许插入的一端叫做队尾 允许删除的一段叫做队头 先进先出的线性表（FIFO） 链队列： #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int QElemType; typedef int Status; //-------单链队列——队列的链式存储结构-------- typedef struct QNode{ QElemType
C语言实现线性表的顺序表示的源码文件
06-11
C语言实现线性表的顺序表示的源码文件 SeqList InitList(); // 初始化线性表 void DestroyList(); // 销毁线性表 void ClearList(); // 清空线性表 int ListEmpty(); // 判断线性表是否为空 int ListLength(); ...
顺序线性表C语言实现
02-01
这个压缩包文件包含的"顺序线性表代码"很可能是C语言实现的顺序存储结构，用于理解和操作顺序线性表。下面我们将深入探讨顺序线性表的概念、特点以及C语言中的实现方法。 顺序线性表是线性表的一种，其中元素按照...
C语言线性表的顺序表示与实现实例详解
09-04
在C语言中，线性表的顺序表示通常采用数组来实现，这是因为数组提供了一种直接访问任意位置元素的高效方式。顺序表的优点在于其随机访问的特性，但插入和删除操作可能需要移动大量元素，效率相对较低。 1. **顺序表...
线性表综合题_C语言_线性表_
09-29
在本题中，我们关注的是如何使用C语言来实现线性表的一些基本操作，包括添加元素（增）、删除元素（删）、修改元素（改）以及查找元素（查）。C语言以其简洁而强大的特性，成为了实现此类算法的理想选择。 首先，...
exit（overflow）
you_best_honor的博客
10-24 4595
**exit（overflow）**意思是越界溢出，常用于C/C++中
overFlow的含义与巧妙使用
qq_42000660的博客
07-17 7358
一、overFlow意义 overflow：容器（满的）溢出，它有以下取值： 1、visible（默认）溢出部分可见 2、hidden溢出部分隐藏 3、auto适当加入滚动条（当父元素高度固定，内容溢出，设置overflow: auto会出现滚动条） overflow-x和overflow-y也有这三种取值，分别代表水平或者垂直方向溢出的处理 二、实现案例 1、默认展示 2、当鼠标悬浮在某一卷时，其他的内容隐藏，该卷展开，效果如下： 3、代码 <!DOCT...
C语言malloc动态分配内存分配失败怎么办？exit(OVERFLOW)；（include ＜cstdlib＞）
Dontla的博客
06-28 5923
如：（见《大话数据结构》147页） QueuePtr s = (QueuePtr)malloc(sizeof(QNode)); if(!s){ exit(OVERFLOW); } exit为C++的退出函数，声明于stdlib.h中，对于C++其标准的头文件为cstdlib,声明为 void exit(int value); exit的功能为，退出当前运行的程序，并将参数value返回给主调进程。 在main中return v;的效果 与exit(v);相同。 OVERFLOW为math.h中的一个
敲线性表代码时遇到的问题（C++)【exit,return】
jikenvhai的博客
04-28 1388
1：exit(OVERFLOW) ①exit简介 为C++的退出函数，声明于stdlib.h中，对于C++其标准的头文件为cstdlib,声明为 void exit(int value); exit(0)：运行正常退出程序 exit(1)：运行异常退出退出程序，返回值1是返回给操作系统的 exit(x)（x不为0）：都表示异常退出 exit的功能为，退出当前运行的程序，并将参数value返回给主调进程。 OVERFLOW为math.h中的一个宏定义，其值为3。含义为运算过程中出现了上溢，即运算结果
C++退出函数exit
08-14 3万+
exit为C++的退出函数，声明于stdlib.h中，对于C++其标准的头文件为cstdlib,声明为 void exit(int value); exit的功能为，退出当前运行的程序，并将参数value返回给主调进程。 在main中return v;的效果 与exit(v);相同。 OVERFLOW为math.h中的一个宏定义，其值为3。含义为运算过程中出现了上溢，即运算结果超出了运算变量
数据结构——顺序表示
shc003218的博客
07-10 323
王卓老师数据结构课程-线性表的顺序表示代码小结
c语言中的exit函数
weixin_42506375的博客
08-29 1万+
exit()通常是用在子程序中用来终结程序用的，使用后程序自动结束，跳回操作系统。 exit(0) 表示程序正常退出,exit⑴/exit(-1)表示程序异常退出。 exit() 结束当前进程/当前程序/，在整个程序中，只要调用 exit ，就结束。             函数用法              函数名: exit() 所在头文件:stdlib.h(如果是"VC6.0"的话...
【C语言】exit函数详解
Kevin ’ s blog
01-29 3407
exit(0)、exit(1)和return
线性表应用小实验
最新发布
03-25
本实验旨在通过实践操作加深对线性表在计算机科学中的理解，包括顺序表和链表两种存储结构。以下是实验的主要内容和目标： 1. 实验预备知识：复习C语言中函数的编写技巧，特别是如何设计和调用函数，以及如何组织...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值