顺序表基本操作及应用-数据结构类C语言

已于 2022-12-16 12:14:06 修改
阅读量604 收藏 3
点赞数
分类专栏： 数据结构基本算法代码 文章标签： 数据结构 c语言 c++ 算法
于 2022-09-30 14:57:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/somewon/article/details/127123634
版权

目录

一、顺序表相关函数声明(before.h)

二、顺序表功能函数定义(func.cpp)

三、顺序表主调函数(main.cpp)

四、运行环境

一、顺序表相关函数声明(before.h)

#ifndef _BEFORE_H
#define _BEFORE_H

typedef int ElemType;
typedef int status;

#define InitSize 10000
#define OK 1
#define ERR 0
#define OVERFLOW (-1)

typedef int ElemType;
typedef int status;

typedef struct {
    ElemType *data;           //指示动态分配数组的指针
    int MaxSize;              //顺序表的最大容量
    int length;               //顺序表的当前长度
}SqList;//顺序表的类型定义动态分配的方式

//顺序表的函数声明
status InitList(SqList &L);                                //建立空的顺序表
status ListEmpty(SqList L);                                //判断顺序表是否为空
status ListLength(SqList L);                               //求顺序表的长度
status PriorElem(SqList L,ElemType cur_e,ElemType &pre_e); //查找直接前驱
status NextElem(SqList L,ElemType cur_e,ElemType &next_e); //查找直接后继
status GetElem(SqList L,int i);                            //查找第i位元素值
status LocateElem(SqList L,int e);                         //查找某元素值位序
status ListTraverse(SqList &L);                            //逆置顺序表
status ClearList(SqList &L);                               //清空顺序表
status DestroyList(SqList &L);                             //销毁顺序表
status CreatElem(SqList &L);                               //创建顺序表
status ListInsert(SqList &L,int i,int e);                  //插入元素
status ListDelete(SqList &L,int i,int &e);                 //删除元素
void PrintList(SqList L);                                  //输出顺序表所有元素

//菜单调用函数声明
void Menu_SqList();

#endif
//
//Created by somewon on 2022/9/29.
//

二、顺序表功能函数定义(func.cpp)

#include <iostream>
#include "before.h"

using namespace std;

//顺序表的相关函数定义
status InitList(SqList &L)
{
    //用malloc申请连续的内存空间
    L.data = (ElemType *)malloc(sizeof(ElemType)*InitSize);
    L.length = 0;             //顺序表初始长度为0
    L.MaxSize = InitSize;
    return OK;
}//建立一个空表

status ListEmpty(SqList L)
{
    if(L.length == 0) return OK;
    else return ERR;
}//判断顺序表是否为空

status ListLength(SqList L)
{
    return (L.length);
}

status PriorElem(SqList L,ElemType cur_e,ElemType &pre_e)
{
    int j = LocateElem(L,cur_e);     //返回cur_e值的位序
    if(j!=ERR && j>2)
    {
        pre_e = L.data[j-2];
        return OK;
    }
    else if(j == ERR) return OVERFLOW;  //不在顺序表中
    else if(j == 1) return ERR;         //首位无直接前驱
}

status NextElem(SqList L,ElemType cur_e,ElemType &next_e)
{
    int j = LocateElem(L,cur_e);
    if(j!=ERR && j<L.length)
    {
        next_e = L.data[j];
        return OK;
    }
    else if(j == ERR) return OVERFLOW; //不在顺序表中
    else if(j == L.length) return ERR; //末位无直接后继
}

status GetElem(SqList L,int i)
{
    if(i<=L.length) return L.data[i-1];
    else return ERR;
}//动静态存储是一样的

status LocateElem(SqList L,int e)
{
    for(int i = 0;i < L.length;i ++)
        if(L.data[i] == e) return i+1;
    return ERR;
}

status ListTraverse(SqList &L)
{
    int i,temp;
    for(i = 0;i < L.length/2;i ++)
    {
        temp = L.data[i];
        L.data[i] = L.data[L.length-1-i];
        L.data[L.length-1-i] = temp;
    }
    return OK;
}//逆置顺序表

status ClearList(SqList &L)
{
    L.length = 0;
    return OK;
}//清空顺序表（只是无法访问而已，数据还在）

status DestroyList(SqList &L)
{
    delete[] L.data;
    return OK;
}//释放顺序表的空间（已经无法访问，数据不在）

status CreatElem(SqList &L)
{
    int cnt = 0;
    ElemType x;
    cin >> x;
    while(x != -1)
    {
        L.data[cnt] = x;
        cnt ++;
        cin >> x;
    }
    L.length = cnt;

    return OK;
}//创建顺序表

status ListInsert(SqList &L,int i,int e)
{
    if(i<1 || i>L.length+1) return ERR;  //判断i是否合理
    if(L.length >= L.MaxSize) return ERR;  //当前存储空间已满，不能插入
    for(int j = L.length;j >= i;j --) L.data[j] = L.data[j-1]; //将第i个元素及之后的元素后移
    L.data[i-1] = e;
    L.length ++;
    return OK;
}//在第i位置上插入元素e

status ListDelete(SqList &L,int i,int &e)
{
    if(i<1 || i>L.length) return ERR;      //判断i值是否合理
    e = L.data[i-1];                       //将删除的值赋给e
    for(int j = i;j < L.length;j ++)
        L.data[j-1] = L.data[j];
    L.length --;                           //长度减少一
    return OK;
}//删除第i个元素

void PrintList(SqList L)
{
    if(L.length == 0) printf("该表目前为空表！\n");
    else
    {
        printf("--当前顺序表中的元素为：\n");
        int numb = 0;
        for(int i = 0;i < L.length;i ++)
        {
            printf("%d\t",L.data[i]);
            numb ++;
            if(numb%7 == 0) printf("\n");
        }
        printf("\n");
    }
}//打印顺序表

//菜单定义
void Menu_SqList()
{
    printf("\t\t\t************************以下为顺序表的菜单*******************************\n");
    printf("\t\t\t\t1、建立空表                       2、创建顺序表                       \n");
    printf("\t\t\t\t3、判断顺序表是否为空              4、查看顺序表的长度                  \n");
    printf("\t\t\t\t5、查看某元素的直接前驱            6、查看某元素的直接后继               \n");
    printf("\t\t\t\t7、查看某位置的数据元素            8、查看某元素的对应位置               \n");
    printf("\t\t\t\t9、将顺序表逆置                   10、清空顺序表                       \n");
    printf("\t\t\t\t11、销毁顺序表                    12、插入元素                         \n");
    printf("\t\t\t\t13、删除元素                      14、输出顺序表所有元素                \n");
    printf("\t\t\t\t15、退出操作系统                                                      \n");
    printf("\t\t\tTips:只有进行完1、2操作之后才能进行后续操作，否则程序出现崩溃！              \n");
    printf("\t\t\t*************************************************************************\n");
}
//
//Created by somewon on 2022/9/29.
//

三、顺序表主调函数(main.cpp)

#include <iostream>
#include "before.h"

using namespace std;

int main() {
    SqList L;
    ElemType cur_e,cur_ee,pre_e,next_e,e;
    int order,choice,fine;
    do{
        Menu_SqList();   //打印对应函数说明菜单
        printf("请输入你的选择： ");
        cin >> choice;
        switch(choice)
        {
            case 1:
                if(InitList(L) == OK) printf("空表建立成功!\n");
                else printf("空表建立失败！请再次尝试！\n");
                break;
            case 2:
                printf("请输入顺序表中的元素，直至-1停止：\n");
                if(CreatElem(L) == OK)
                {
                    printf("创建顺序表成功！\n");
                    PrintList(L);
                }
                else printf("创建顺序表失败!\n");
                break;
            case 3:
                if(ListEmpty(L) == OK) printf("该表为空表!\n");
                else printf("该表不为空！\n");
                break;
            case 4:
                printf("该表的长度为%d!\n",ListLength(L));
                break;
            case 5:
                printf("请输入需要查询直接前驱的元素值： ");
                cin >> cur_e;
                pre_e = -1;
                fine = PriorElem(L,cur_e,pre_e);
                if(fine == OK) printf("该元素的直接前驱为：%d\n",pre_e);
                else if(fine == ERR)printf("该元素无直接前驱!\n");
                else printf("该元素不在顺序表中！\n");
                break;
            case 6:
                printf("请输入需要查询直接后继的元素值： ");
                cin >> cur_ee;
                next_e = -1;
                fine = NextElem(L,cur_ee,next_e);
                if(fine == OK) printf("该元素的直接后继为：%d\n",next_e);
                else if(fine == ERR) printf("该元素无直接后继！\n");
                else printf("该元素不在顺序表中！\n");
                break;
            case 7:
                printf("请输入需要查询的位置: ");
                cin >> order;
                e = GetElem(L,order);
                if(e == ERR) printf("该位序不合理！\n");
                else printf("该位置的元素值为：%d\n",e);
                break;
            case 8:
                printf("请输入需要查看的元素：");
                cin >> e;
                if(LocateElem(L,e) != ERR) printf("该元素所在位置为：%d\n",LocateElem(L,e));
                else printf("该元素不在顺序表中！\n");
                break;
            case 9:
                if(ListTraverse(L) == OK)
                {
                    printf("顺序表逆置成功！\n");
                    PrintList(L);
                }
                else printf("该表逆置失败，请再次尝试！\n");
                break;
            case 10:
                if(ClearList(L) == OK) printf("该表清空成功!\n");
                else printf("清空顺序表失败，请再次尝试操作!\n");
                break;
            case 11:
                if(DestroyList(L) == OK) printf("该顺序表销毁成功!\n");
                else printf("销毁失败，请再次进行操作!\n");
                break;
            case 12:
                printf("请输入需要插入的元素值：");
                cin >> e;
                printf("请输入该元素插入的位序：");
                cin >> order;
                if(ListInsert(L,order,e) == OK)
                {
                    printf("该位置元素插入成功！\n");
                    PrintList(L);
                }
                else printf("请检查插入位置或元素类型，再次进行操作!\n");
                break;
            case 13:
                printf("请输入需要删除的元素位序：");
                cin >> order;
                if(ListDelete(L,order,e) == OK)
                {
                    printf("该位序上的元素删除成功，被删除的元素值为：%d\n",e);
                    PrintList(L);
                }
                else printf("请检查需要删除的位序是否合理，删除失败！\n");
                break;
            case 14:
                PrintList(L);
                break;
            case 15:
                goto END;
            default:
                printf("无该操作，请再次进行选择！\n");
        }
    }while(choice);
    END:
    printf("谢谢您的使用！欢迎下次光临嘿哈！\n");

    return 0;
}
//
// Created by somewon on 2022/9/29.
//

四、运行环境

        CLion

_慢漫漫慢
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构—顺序表的销毁
qq_39830449的博客
08-20 1万+
//顺序表的销毁 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define OK 1 #define OVERFLOW -2 #define LIST_INIT_SIZE 10// 线性表存储空间的初始分配量 typedef int Status; //Status是函数数据类型 ，其值是函数结果状态，如OK typedef ...
数据结构之线性表-顺序表的基本操作及其应用总结(带有详细注释及说明)
Carson's Blog
05-04 2940
顺序表的基本操作 顺序表的定义及初始化 /*顺序表的定义*/ #include <stdio.h> #include <malloc.h> #define MAX_SIZE 100 //数组最大长度 typedef int ElemType; //数据类型的别名 //定义线性表结构体 typedef struct sqlist { ElemType *data; //声明了一个名为data的长度不确定的数组，也叫“动态数组” int length; //记录
顺序表初始化
热门推荐
Lianuuu的博客
10-04 1万+
1. 顺序表 顺序表(顺序存储结构) 存储数据时，会提前申请一整块足够大小的物理空间，然后将数据按照次序依次存储到一整块连续的存储空间，存储时做到数据元素之间不留一丝缝隙 使用顺序表存储集合 {1,2,3,4,5}，数据最终的存储状态如图所示： 1.1. 顺序表的初始化 顺序存储结构需要如下三个属性： 存储空间的起始地址：数组的起始地址 顺序表的最大存储容量：数组长度size 顺序表的当前长度，也就是表中存储数据元素的个数：length 自定义顺序表结构的C代码： typedef struct Tab
1.顺序表的各种基本操作（函数原型）
everlastingYu的博客
04-15 768
void InitList(SqList *&amp;L)          //初始化线性表，构造一个空的线性表，并将长度设置为0   { L = (SqList *)malloc(sizeof(SqList)); L-&gt;length = 0; } void DestroyList(SqList *L)        //销毁线性表，即释放线性表所占用的内存空间   { f...
【数据结构】顺序表实验
qq_45857607的博客
10-24 1553
线性表：零个或多个数据元素的有限序列。 线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。 1、掌握顺序表中元素的前驱、后续的概念。 顺序表的前驱与后继指的是当前元素前一个元素与后一个元素分别是什么。如图所示，a[i-1]与a[i+1]分别是a[i]的前驱与后继。 2、掌握顺序表的建立、插入元素、删除表中某元素的操作。 //测试程序样例： #include <stdio.h> #include <stdlib.h> #define OK 1.
数据结构学习--线性表及其应用--顺序表
06-25
通过这样的实验，学习者能够更好地理解顺序表的特性和基本操作，为后续学习更复杂的数据结构如树、图等打下坚实的基础。同时，对顺序存储结构的熟悉也有助于提升对数组、指针等基础知识的运用能力。在实际编程中，...
PTA—C语言数据结构：顺序表.ppt
10-11
本文件"PTA—C语言数据结构：顺序表.ppt"是针对PTA（Programming Training Assistant）平台上数据结构课程的一个教学资源，专门探讨了顺序表这一基本数据结构，并提供了相关练习题的解答。下面我们将详细讨论顺序表...
c语言实现顺序表的基本操作
09-04
"c语言实现顺序表的基本操作" 顺序表是数据结构中的一种常见的数据结构，它是一种线性表，元素...使用c语言实现顺序表的基本操作是非常重要的，它可以帮助我们更好地理解顺序表的工作原理，并且可以应用于实际项目中。
c语言 数据结构实验二 顺序表的应用
05-31
在本实验中，我们主要探讨了C语言实现数据结构中顺序表的应用。顺序表是一种基本的数据结构，它在内存中连续存储元素，便于进行插入、删除等操作。在这个实验中，我们创建了一个名为`patient`的结构体，用于存储病人...
C语言数据结构-顺序表版学生管理系统
最新发布
09-26
在本项目" C语言数据结构-顺序表版学生管理系统 "中，我们将聚焦于一种基础的数据结构——顺序表，以及如何利用C语言实现一个学生管理系统的具体应用。 顺序表是一种线性数据结构，它的特点是元素在内存中按顺序...
顺序表销毁
骆驼胡杨的博客
07-24 3261
顺序表销毁之后不可进行添加数据, 插入数据, 以及删除数据等操作 #include <iostream> #include <Windows.h> #include <string> using namespace std; #define MAX_SIZE 100 typedef struct { int *elems; //顺序表的基地址 int length; //顺序表的长度 int size; //顺序表总空间大小 } Sqlist; boo
数据结构-c语言代码实现-顺序表的基本操作
m0_65204379的博客
11-21 1025
看了严蔚敏教授的书和王道考研，结合而写的代码。
线性顺序表相关的函数及对函数的调用实例化
qq_46176868的博客
09-24 640
#include<iostream> #define max 10 typedef int abc; using namespace std; struct lian { abc date[max]; int length; }; class lei { public: void creat(lian*& l, abc a[], int n) {//创建一个顺序线性表 int i; int k = 0; l = (lian*)malloc(sizeof(lian)
实验二：顺序表的基本操作实现及其应用
sendyxu的博客
04-26 2852
1.建立一个由8位同学成绩的顺序表，实现数据的插入，删除，查找等操作，分别输出结果。#include&lt;iostream&gt;  using namespace std;  const int max=100;  template &lt;typename T&gt;  class SeqList{      public:          SeqList(T score[],int n)...
C语言实现顺序表的基本操作
weixin_40909099的博客
04-08 1436
顺序表通俗来说就是一个有着元素个数记录的数组，在这个数组进行增删查改的操作，顺序表的基本操作练习的是一个人对算法的思想和对一门编程语言的应用，作为计算机编程学习者应该多动手实践，下面是代码#include<stdio.h> #pragma warnimg(disable:4996) typedef int Datatypedef; #define MAX_arr 10 typedef struct
顺序表_主程序
JUSTfFUN的博客
02-07 422
顺序表检验bo2-1.h的主程序 以下内容为main2-1.cpp /* * 时间：2021.01.30 * 内容：检验 bo2-1.h 的主函数，也是线性表主要功能检验主函数 * 位置： * 高书p15 */ #include "c1.h" typedef int ElemType; // 定义ElemType为整型 #include "c2-1.h" //线性表的顺序存储结构 #include "bo2-1.h" //线性表顺序存储结构的基本操作 #include "fun2-2.
《大话数据结构》读书笔记之线性表基本操作（单链表实现）
QiaoRuoZhuo的专栏
09-11 854
/* Name: 线性表抽象数据类型（使用单链表实现）  Copyright:  Author: 巧若拙  Date:11-09-14 23:34 Description:  */ #include #include #include #include #define MAXSIZE 10 #define OK 1 #define ERROR 0 #de
C语言实现数据结构：顺序表操作实验指南
"数据结构实验指导书C语言版主要涵盖了线性表的顺序存储结构——顺序表的操作，包括建立、插入、删除和查找等基本操作。实验旨在通过C语言编程实现，让学生掌握顺序表的表示和实现方法，熟悉相关算法，并进行实际...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值