线性表的顺序存储—顺序表，突然的自我

最新推荐文章于 2024-09-27 23:56:15 发布
最新推荐文章于 2024-09-27 23:56:15 发布
阅读量169 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjhqukq/article/details/111125122
版权

先看代码整体结构

在这里插入图片描述

再看运行效果

初始化顺序表

在这里插入图片描述

追加元素

在这里插入图片描述

定位元素的下标

在这里插入图片描述

通过元素下标获取元素

在这里插入图片描述

插入元素

在这里插入图片描述

排序

在这里插入图片描述

删除元素

在这里插入图片描述

修改指定下标的元素值

在这里插入图片描述

清空顺序表后，操作菜单就会呈现提示“顺序表已清空”在这里插入图片描述

顺序表清空后，若再次进行某些函数操作，函数也会给出提示“顺序表已清空”。这里就拿顺序表的遍历和排序作示例
在这里插入图片描述
在这里插入图片描述

最后看代码？我还是复制粘贴后直接运行吧！读程真的很累！ 

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
#define MAXSIZE 6//顺序表的最大长度
#define SPAN 35;//菜单的水平跨度
#define VerticalGap 2//菜单的垂直间距，1就是一个换行，2就是两个换行
typedef struct ArrayList
{
    int* origin;//数据的来源，在结构体初始化后，与一段连续的内存单元建立联系，并操作这一块内存单元
    int length;//顺序表的最大长度，记录顺序表的最大容量，能存放多少个元素
    int counter;//顺序表的计数器，记录当前元素的个数
}* ListPointer,List;
ListPointer initialize();//初始化顺序表
void manifest(ListPointer lp);//遍历顺序表
void sort(ListPointer lp);
void append(ListPointer lp,int value);//为顺序表追加元素，也就是在顺序表末尾添加一个元素
void insert(ListPointer lp,int position,int value);//在顺序表指定的位置下插入一个值
void delete(ListPointer lp,int position);//删除顺序表中某一元素的值
void modify(ListPointer lp,int position,int value);//修改表中的某一元素值
void getElement(ListPointer lp,int position,int* value);//给定元素下标，返回元素值
void locateElement(ListPointer lp,int value,int* position);//定位元素，返回元素的下标
void clear(ListPointer lp);//清空顺序表
int judge(ListPointer lp,int position,char* executive);//判断在顺序表lp上,第position位置进行executive操作是否能够进行，这里的executive是函数名，
int isEmpty(ListPointer lp);//判断顺序表是否为空
int isFull(ListPointer lp);//判断顺序表是否已满
void inputData(int* data,char* dataExplanation);//录入数据，因为要反复使用scanf和printf这两个函数，干脆做一个提取
void menu(char** menu,int length);//动态地输出菜单
void duplicate(int size,char token);//给出一个整数size和一个字符型符号token，输出size个token,不换行
int main() {
    char* operatingMenu[] = {
            "1.reinitialize list", "2.present list", "3.append element",
            "4.delete element", "5.modify element", "6.insert element",
            "7.get element","8.locate element","9.sort",
            "10.clear list", "11.exit"};
    int length=sizeof(operatingMenu)/sizeof(char*);
    int indicator,position,value;
    ListPointer lp=NULL;
    printf("initializing...\n");
    lp=initialize();
    while(1)
    {
        system("cls");
        menu(operatingMenu,length);
        (lp!=NULL && !isEmpty(lp))?manifest(lp):printf("The List Is Empty.Data are required!Press 1 or 3 to renew.\n");
        inputData(&indicator,"digital indication:");
        switch(indicator)
        {
            case 1:free(lp);lp=initialize();break;//销毁之前的顺序表，并重新初始化一个顺序表
            case 2:manifest(lp);system("pause");break;
            case 3:{
                inputData(&value,"VALUE:");
                append(lp,value);
                system("pause");
                break;
            }
            case 4:{
                inputData(&position,"POSITION:");
                if(judge(lp,position,"delete"))
                {
                    delete(lp,position);
                }
               system("pause");
                break;
            }
            case 5:
            {
                inputData(&position,"POSITION:");
                if(judge(lp,position,"modify"))
                {
                    inputData(&value,"VALUE:");
                    modify(lp,position,value);
                }
                system("pause");
                break;
            }
            case 6:{
                inputData(&position,"POSITION:");
                if(judge(lp,position,"insert"))
                {
                    inputData(&value,"VALUE:");
                    insert(lp,position,value);
                }
                system("pause");
                break;
            }
            case 7:
                inputData(&position,"POSITION:");
                if(judge(lp,position,"getElement"))
                {
                    getElement(lp,position,&value);
                    printf("The element of position %d :\t%d\n",position,value);
                }
                system("pause");
                break;
            case 8:
                inputData(&value,"VALUE:");
                if(judge(lp,666,"locateElement"))
                {
                    locateElement(lp,value,&position);
                    position>0?printf("The position of element %d :\t%d\n",value,position):printf("The element doesn't exist!");
                }
                system("pause");
                break;
            case 9:sort(lp);system("pause");break;
            case 10:clear(lp);system("pause");break;
            case 11:free(lp);exit(-1);//销毁顺序表，并退出
        }
    }
}
ListPointer initialize() {
    ListPointer lp=(ListPointer)malloc(sizeof(List));
    lp->length=MAXSIZE;
    lp->origin=(int*)malloc(sizeof(int)*lp->length);
    lp->counter=0;
    int length;
    inputData(&length,"The length of List(0<length<6):");
    if(length<=0 || length>lp->length)
        exit(-1);
    for (int i = 0; i < length; ++i) {
        printf("element %d:",i+1);
        scanf("%d",lp->origin+i);
        ++lp->counter;
    }
    return lp;
}
void manifest(ListPointer lp)
{
    if(!judge(lp,666,"manifest"))
        return;
    printf("{");
    for (int i = 0; i < lp->counter; ++i) {
        if(i<lp->counter-1)
            printf("%d,",lp->origin[i]);
        else
            printf("%d}\n",*(lp->origin+i));
    }
}
void sort(ListPointer lp)//这里选用插入排序
{
    if(!judge(lp,666,"sort"))
        return;
    int retreat,shirley;
    for (int i = 1; i < lp->counter; ++i) {
        shirley=lp->origin[i];
        for (retreat =i-1; retreat>=0 && shirley<lp->origin[retreat]; --retreat) {
            lp->origin[retreat+1]=lp->origin[retreat];
        }
        lp->origin[retreat+1]=shirley;
    }
    printf("sorting is finished!\n");
}
void append(ListPointer lp,int value)
{
    if(!judge(lp,666,"append"))//666相当于良民证
    {
        return;
    }
    lp->origin[lp->counter]=value;
    ++lp->counter;
}
void insert(ListPointer lp,int position,int value)
{
    if(!judge(lp,position,"insert"))
    {
        return;
    }
    lp->counter++;
    for (int i = lp->counter; i>position; --i) {
        lp->origin[i-1]=lp->origin[i-2];
    }
    lp->origin[position-1]=value;
    printf("The element was inserted into list completely!\n");
}
void delete(ListPointer lp,int position)
{
    if(!judge(lp,position,"delete"))
    {
        return;
    }
    int value=lp->origin[position-1];
    for (int i = position; i <lp->counter ; ++i) {
        lp->origin[i-1]=lp->origin[i];
    }
    --lp->counter;
    printf("The element whose position is %d and value is %d was deleted completely!\n",position,value);
}
void modify(ListPointer lp,int position,int value)
{
    judge(lp,position,"modify")?lp->origin[position-1]=value:printf("operate once more please!!!");
}
void getElement(ListPointer lp,int position,int* value)
{
    if(judge(lp,position,"getElement"))
       *value=lp->origin[position-1];
}
void locateElement(ListPointer lp,int value,int* position)
{
    int flag=0;
    if(judge(lp,666,"locateElement"))
    {
        for(int  i = 0; i < lp->counter; ++i) {
            if(lp->origin[i]==value)
            {
                *position=i+1;
                flag=1;
            }
        }
        if(flag==0)
            *position=-1;
    }
}
void clear(ListPointer lp)
{
    lp->counter=0;
    printf("The List Was Cleared.Press 1 or 3 to renew!\n");
}
int judge(ListPointer lp,int position,char* executive)
{
    if(isEmpty(lp)&&(!strcmp(executive,"delete")
    ||!strcmp(executive,"modify")||!strcmp(executive,"manifest")
    ||!strcmp(executive,"insert")||!strcmp(executive,"getElement")
    ||!strcmp(executive,"locateElement")||!strcmp(executive,"sort")))
    {
        printf("The List Is Empty!\n");
        return 0;
    }
    if(isFull(lp) && (!strcmp(executive,"append") || !strcmp(executive,"insert")))
    {
        printf("The List Is Full!\n");
        return 0;
    }
    if(position==666)//验证函数操作是否合法时，666表示当前的函数无需指定下标去操作，相当于良民证“放行”
        return 1;
    if(position>lp->counter || position<=0)
    {
        printf("invalid position!\n");
        return 0;
    }
    return 1;
}
int isEmpty(ListPointer lp)
{
    return lp->counter==0?1:0;
}
int isFull(ListPointer lp)
{
    return lp->counter==lp->length?1:0;
}
void inputData(int* data,char* dataExplanation)
{
    printf("%s",dataExplanation);
    scanf("%d",data);
}
void menu(char** origin,int length) {
    int span=SPAN;
    int gapLength;
    duplicate(span,'*');
    duplicate(1,'\n');
    for (int i = 0; i < length; ++i) {
        duplicate(1,'*');
        gapLength=span-(strlen(*(origin+i)))-2;
        duplicate(gapLength/2,' ');
        printf("%s",origin[i]);
        if(gapLength%2==0)
        {
            duplicate(gapLength/2,' ');
        }else
        {
            duplicate(gapLength/2+1,' ');
        }
        duplicate(1,'*');
        duplicate(VerticalGap,'\n');
    }
    duplicate(span,'*');
    duplicate(1,'\n');
}
void duplicate(int size,char token)
{
    for (int i = 0; i <size ; ++i) {
        printf("%c",token);
    }
}

尽管累，但是我们在读程的过程中会不知不觉地成长着，提升着自己的读程能力，在潜移默化中也改善了我们的编程能力，加强了我们做事的耐心！共勉！

yjhqukq
关注
专栏目录
线性表顺序存储运算的算法实现
09-03
在计算机科学中，线性表的顺序存储是常用的数据组织方式，其特点是元素在内存中按顺序连续存放。本话题将深入探讨线性表的顺序存储结构及其在C语言中的算法实现，包括线性表的输入输出、插入、删除以及长度和置空...
线性表的顺序存储与实现
07-29
线性表是计算机科学中一种基础的数据结构，它是由n（n≥0）个相同...提供的文件"02-线性表的顺序存储与实现"很可能是关于如何在具体编程语言中实现这些操作的示例代码，可以作为学习和理解线性表顺序存储的参考资料。
线性表的顺序存储结构
那年聪聪
05-06 9001
线性表的顺序存储结构
数据结构之线性表的顺序存储——顺序表
jiaomubai的博客
01-20 738
线性表 线性表即零个或多个数据元素的有限序列。首先它是一个序列，其次它的元素之间是有顺序的，若存在多个元素，则首个元素无前驱，末尾元素无后继，除此之外，每个元素都有一个前驱和一个后继。用n来表示线性表元素的个数，当n=0时，即表明线性表中无元素，称为空表。 线性表又可分为动态线性表和静态线性表。静态线性表的容量大小是固定的，而动态线性表的容量可根据表中元素实现自动扩容。 线性表的顺序存储结构——顺...
线性表的顺序存储
cherry的博客
05-03 2081
线性表的顺序存储 线性表的顺序存储结构：用一段地址连续的存储单元依次存储线性表的数据元素。 线性表的元素类型相同，用一段连续的地址存储，可以使用数组来存储实现线性表的顺序存储。 线性表的存储结构代码如下。 class MyArrayList{ private final static int MAXSIZE = 2; //线性表数组的初始长度,这里设置2是为了测试 int[] data...
线性表的顺序存储和操作
cheng5055251的博客
04-23 1220
一、 实验目的 用顺序表(SqList)类型实现书上算法2.1和2.2，了解线性表及在计算机中的两类不同的存储结构；熟练掌握线性表的查找、插入和删除等算法并灵活运用这些算法。 二、 实验内容 用C语言编写程序，其中Lb={2,4,6,8,10} La={1,2,3,4,5}, ① 算法2.1执行后，得到的new La = 1,2,3,4,5,6,8,10 ② 修改Lb=2,6,8,9,11,15...
顺序表——线性表的顺序存储
weixin_65477256的博客
07-27 692
线性表中的数据元素在内存中存储方式包含两种存储方式：顺序存储结构：​ 所谓的顺序存储结构，指的是在内存中开辟连续存储空间，并将线性表中的元素按照存储位置序号连续存储。此时所构成的线性表称为顺序表。​ 类似于C语言程序中的数组，不同于数组的时候，需要保证元素连续存储。链式存储结构：​ 所谓的链式存储结构，指的是采用非连续存储空间存储线性表中的所有数据元素，其中每一个数据元素需要存储当前元素的数据内容和后继数据元素存储空间的地址。可以通过数据元素存储空间的地址表示数据元素的逻辑关系。
5.线性表：顺序表与链表
speedwalkman的专栏
07-02 1028
本章主要介绍线性表的定义，线性表的顺序存储和链式存储，线性表的前驱和后继。以及顺序表(顺序存储结构)与链表（单链表），顺序表与数组的关系和区别和顺序表与链表（单链表）的基本操作。
【数据结构】线性表与顺序表
weixin_63449996的博客
07-29 3896
数据结构：线性表，顺序表
C语言线性表顺序存储结构实例详解
08-30
本资源为C语言线性表顺序存储结构实例详解，涵盖了顺序存储结构的定义、线性表的顺序存储结构的实现、顺序表的初始化操作、获取元素操作、插入操作和删除元素操作等方面，为学习C语言线性表顺序存储结构的朋友提供了...
C++ 线性表的顺序存储：顺序表(静态)
01-06
顺序表的基本操作： void InitList(sqList &L);//初始化顺序表 void CreateList(sqList &L,int n);//创建顺序表 void PrintList(sqList L);//打印顺序表 void InsertElem(sqList &L,int i,int e);//插入元素 void ...
线性表的存储结构与顺序表的存储实现共4页.pdf.zip
11-25
在实际应用中，线性表的存储结构通常有两种主要形式：顺序存储结构和链式存储结构。 顺序存储结构是将线性表中的元素按其逻辑顺序依次存放在一片连续的内存区域中，这种存储方式使得数据访问变得简单且高效。顺序表...
顺序存储线性表实现菜单功能|数据结构
LLLLQZ的博客
10-28 1129
#include<stdio.h> #include<conio.h> #include<stdlib.h> #include<time.h> #define MAX 100 typedef struct { int data[MAX]; int listlen; }sqList; //菜单显示 void Menu() { printf("■■■■■■■■■■■■■■■■■■■■■■■■■\n"); printf("■
（JAVA）队列 和 符号表 两种数据结构的实现
最新发布
ZunXin_2580的博客
09-27 616
如果想要清晰的认识队列或者符号表是怎样的结构，那么就来看看这篇文章吧！！
[数据结构] 二叉树题目(一)
nmbg11的博客
09-27 479
leetcode有关二叉树的相关题目. 翻转二叉树. 相同的树. 对称二叉树.
数据结构（Map、Set、搜索树）
wuweixiaoyue的博客
09-27 834
概念优势：查找元素时可以直接砍去一半的值，达到 log(N)示例：此时如果要找4，因为4比6小，所以要去6的左边找，此时因为4比3大，所以要去3的右树找，最终找到了如果找到了就返回，如果直到全部找完遇到null了也没找到，说明该搜索树下根本就没有该元素有序问题：二叉搜索树的中序遍历是有序的概念：Map和Set是专门用来进行搜索的容器或数据结构Set是纯key模型，Map是 Key-Value 模型Set最大的功能就是对集合中的元素进行去重接口实例化。
数据结构-4.栈与队列
2302_81886858的博客
09-25 1160
本篇博客给大家带来的是的知识点, 其中包括两道文章专栏:Java-数据结构若有问题 评论区见欢迎大家如果你不知道分享给谁,那就分享给薯条, 如果分享不成功, 那我就会回你一下,那样你就分享成功啦.你们的支持是我不断创作的动力 .
数据结构：排序（内部排序+各种排序算法的性质总结）
pranaa的博客
09-26 1218
数据元素：这是排序操作的基本单位，可以是一个数字、一个字符串，或者是一个包含多个字段的记录等。关键字：用于比较的数据元素中的某个属性或字段，排序算法依据这个关键字的值来决定数据元素的顺序。例如，对于一组学生的记录，我们可以选择学生的年龄或分数作为关键字进行排序。排序规则：即数据元素之间的比较准则，决定了数据元素在排序后的序列中的相对位置。排序规则通常是基于关键字的值，可以是升序（从小到大）或降序（从大到小）。排序算法：是实现排序的具体步骤和方法，不同的排序算法有不同的时间复杂度、空间复杂度和稳定性等特性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值