顺序表-静态创建方式

最新推荐文章于 2022-09-17 15:48:09 发布
原创 最新推荐文章于 2022-09-17 15:48:09 发布 · 515 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #顺序表 #静态方式创建 #王道 #考验数据结构

本文介绍了一个关于线性表顺序存储结构的练习程序，涵盖了增删改查等基本操作，并实现了元素排序功能。通过一个菜单驱动的界面，用户可以方便地测试和理解线性表的基本概念。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

/***********************************************
Description: 对于线性表的练习
		第一部分关于线性表中的顺序存储结构的练习
		本部分主要是包括对于线性表顺序存储结构的各种操作（增、删、该、查）
		本次采用的数据结构为静态方式，下一节介绍动态的方式
Author: qichaoqun
Date: 2019/07/06
************************************************/
#include <stdio.h>
#include <stdlib.h>

/*定义数组的大小为 10 个 */
#define MAX_SIZE  10

/*定义本次线性表的存储的数据的类型为 int 型，并为其起一个别名*/
typedef int ElemType;

/*采用静态方式创建线性表*/
typedef struct {
    //数组
    ElemType data[MAX_SIZE];
    //数组当前的长度
    int length;
} SqlList;

/* 显示菜单 */
void showMenu();

/*增加一个元素在数组中*/
bool addElement(SqlList &sqlList);

/*删除一个元素*/
bool deleteElement2(SqlList &sqlList, int position);

/*根据位置，显示一个元素*/
void showElement(SqlList &sqlList, int position);

/*修改一个元素*/
bool updateElement(SqlList &sqlList, int position, int element);

/*将所有元素按从小到大的顺序排列输出*/
void showElementOrderByLow(SqlList &sqlList);

/*将所有元素按从大到小的顺序排列输出*/
void showElementOrderByHigh(SqlList &sqlList);

/*显示当前数组中的所有的元素*/
void showElements(SqlList &sqlList);

/*在任意位置插入一个元素*/
bool insertElement(SqlList &sqlList,int element,int position);

int main() {
    //顺序表
    SqlList sqlList;
    sqlList.length = 0;
    showMenu();
    while (true) {
        int option;
        scanf("%d", &option);
        if (option == 1) {
            //添加一个元素
            if (addElement(sqlList)) {
                //添加成功
                printf("添加元素成功\n");
            } else {
                //添加失败
                printf("添加元素失败\n");
            }
        } else if (option == 2) {
            int position;
            printf("请输入你要删除的元素的位置 ");
            scanf("%d", &position);
            //删除一个元素
            if (deleteElement2(sqlList, position)) {
                //删除成功
                printf("删除元素成功\n");
            } else {
                //删除失败
                printf("删除元素失败\n");
            }
        } else if (option == 3) {
            //显示元素
            printf("请输入你想要显示的元素的位置 ");
            int position;
            scanf("%d", &position);
            showElement(sqlList, position);
        } else if (option == 4) {
            //修改元素
            printf("请输入你要修改的元素的位置和修改的内容 ");
            int element;
            int position;
            scanf("%d", &position);
            scanf("%d", &element);
            if (updateElement(sqlList, position, element)) {
                //修改成功
                printf("修改成功\n");
            } else {
                //修改失败
                printf("修改失败,输入的位置不合法\n");
            }
        } else if (option == 5) {
            // 按从小到大的顺序显示
            showElementOrderByLow(sqlList);
        } else if (option == 6) {
            //按从大到小的顺序显示
            showElementOrderByHigh(sqlList);
        } else if (option == 7) {
            //显示所有的元素
            showElements(sqlList);
        } else if (option == 8) {
            //在指定的位置插入一个元素
            int element;
            int position;
            printf("请输入你要插入的元素和插入的位置 ");
            scanf("%d",&element);
            scanf("%d",&position);
            if(insertElement(sqlList,element,position)){
                printf("插入成功\n");
            }else{
                printf("插入失败\n");
            }
        } else if(option == 9){
            //退出
            break;
        }else{
            //输入不合法
            printf("输入不合法，请重新输入\n");
        }
        showMenu();
    }
    return 0;
}

/*将所有元素按从大到小的顺序排列输出*/
void showElementOrderByHigh(SqlList &sqlList) {
    //定义一个新的数组用来承接
    SqlList newSqlList;
    //将newSqlList的初始化长度置位 0
    newSqlList.length = 0;
    int i;
    for (i = 0; i < sqlList.length; i++) {
        newSqlList.data[i] = sqlList.data[i];
        newSqlList.length++;
    }
    //将新的数组中的内容进行排序
    for (int i = 0; i < newSqlList.length - 1; i++) {
        for (int j = 0; j < newSqlList.length - i - 1; j++) {
            if (newSqlList.data[j] < newSqlList.data[j + 1]) {
                //交换位置
                int temp = newSqlList.data[j];
                newSqlList.data[j] = newSqlList.data[j + 1];
                newSqlList.data[j + 1] = temp;
            }
        }
    }

    printf("从大到小排列为：");
    for (int i = 0; i < newSqlList.length; i++) {
        printf("%d ", newSqlList.data[i]);
    }
    printf("\n");
}

/*将所有元素按从小到大的顺序排列输出*/
void showElementOrderByLow(SqlList &sqlList) {
    //定义一个新的数组用来承接
    SqlList newSqlList;
    newSqlList.length = 0;
    for (int i = 0; i < sqlList.length; i++) {
        newSqlList.data[i] = sqlList.data[i];
        newSqlList.length++;
    }
    //将新的数组中的内容进行排序
    for (int i = 0; i < newSqlList.length - 1; i++) {
        for (int j = 0; j < newSqlList.length - i - 1; j++) {
            if (newSqlList.data[j] > newSqlList.data[j + 1]) {
                //交换位置
                int temp = newSqlList.data[j];
                newSqlList.data[j] = newSqlList.data[j + 1];
                newSqlList.data[j + 1] = temp;
            }
        }
    }

    printf("从小到大排列为：");
    for (int i = 0; i < newSqlList.length; i++) {
        printf("%d ", newSqlList.data[i]);
    }
    printf("\n");
}

/*修改一个元素*/
bool updateElement(SqlList &sqlList, int position, int element) {
    if (position < sqlList.length) {
        //位置合法，允许修改
        sqlList.data[position] = element;
        return true;
    }
    return false;
}

/*显示所有的元素*/
void showElements(SqlList &sqlList) {
    printf("当前的元素为：");
    for (int i = 0; i < sqlList.length; i++) {
        printf("%d ", sqlList.data[i]);
    }
    printf("\n");
}

/*根据位置，显示一个元素*/
void showElement(SqlList &sqlList, int position) {
    if (position < sqlList.length) {
        printf("该元素为: %d\n", sqlList.data[position]);
    } else {
        printf("请输入的位置不合法，重新输入\n");
    }
}

/*删除一个元素*/
bool deleteElement2(SqlList &sqlList, int position) {
    if (position <= sqlList.length) {
        //位置合法，则进行删除
        int i;
        for (i = position; i < sqlList.length; i++) {
            sqlList.data[i] = sqlList.data[i + 1];
        }
        sqlList.length--;
        return true;
    }
    return false;
}

/*在任意位置插入一个元素*/
bool insertElement(SqlList &sqlList,int element,int position){
    //判断位置是否合法
    if(position < MAX_SIZE){
        //判断是否还有空余位置
        if(sqlList.length < MAX_SIZE){
            //将元素插入到指定的位置
            for (int i = position; i < sqlList.length; ++i) {
                //指定位置之后的所有的元素的位置都要后移
                sqlList.data[i+1] = sqlList.data[i];
            }
            //在该位置插入元素
            sqlList.data[position] = element;
            //更新数组的大小
            sqlList.length++;
            return true;
        }else{
            printf("没有空余的位置可供插入\n");
        }
    }else{
        printf("你输入的位置不合法，请重新输入\n");
    }
    return false;
}

/*增加一个元素在数组中*/
bool addElement(SqlList &sqlList) {
    int x;
    printf("请输入你要添加的元素：");
    scanf("%d", &x);
    if (sqlList.length < MAX_SIZE) {
        //数组中还有位置，则进行元素的添加
        //并且返回添加成功
        sqlList.data[sqlList.length] = x;
        sqlList.length++;
        return true;
    }
    return false;
}

/*
显示菜单
*/
void showMenu() {
    printf("  线性表的操作\n");
    printf("1 添加元素\n");
    printf("2 删除一个元素\n");
    printf("3 显示一个元素\n");
    printf("4 修改一个元素\n");
    printf("5 将元素按从小到达的顺序排列\n");
    printf("6 将元素按从大到小的顺序排列\n");
    printf("7 显示所有的元素\n");
    printf("8 在指定的位置插入一个元素\n");
    printf("9 退出\n\n");
    printf(" 请输入你的操作：");
}
静态数组创建顺序表创建及其操作
xiomarazark的博客
08-04 223
顺序表 #include <stdlib.h> #include <stdio.h> #define Elemtype int #define MaxSize 10 typedef struct { Elemtype data[MaxSize]; int length; } SqList; //初始化顺序表 void InitList(SqList &L) { for (int i = 0; i < MaxSize; i++) {
实现静态顺序表
gy的博客
03-23 288
//seqlist.h #pragma once #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; #include&lt;assert.h&gt; #define MAX_SIZE 10 //数组元素的个数 typedef unsigned int size_t; typedef int Da...
创建一个静态的顺序表存放整数
04-17
创建一个静态的顺序表存放整数。大小为10.完成以下的操作输入6个整数，1.打 印出顺序表中的内容，并显示表中剩余的空间个数。在顺序表中的第3个位置插入元素O.2.打印出顺序表中的内容，并显示表中剩余的空间个数。再试图向表中第11个位置插入整数0,3.程序提示超出范围。4.删除表中第6个元素，打印出顺序表中的内容，并显示表中剩余的空间个数。 二：编写一程序，动态地创建一个顺序表。要求顺序表初始长度为20,向顺序表中输 入15个整数，并打印出来: 再删除顺序表中的第5个元素。打印出删除后的结果。
顺序表的静态建立
weixin_34072458的博客
12-24 164
1 #include<stdio.h> 2 #define MaxSize 100 3 typedef int Elemtype; 4 typedef struct{ 5 Elemtype data[MaxSize]; 6 int length; 7 }SqList; 8 9 /*插入元素操作*/ 10 bool ListIns...
顺序表的静态创建
junfuyou的博客
08-04 319
#include <stdio.h> #define MaxSize 10 typedef struct { int data[MaxSize]; //静态初始化存放数据 int length; //元素的个数 }SeqList; //初始化 void InitList(SeqList *L) { for (int i = 0; i < MaxSize; i++) { L->data[i] = 0; }
C语言顺序表的静态建立
m0_51894865的博客
09-17 532
2. 除最后一个元素以外，每个元素都有一个后继；1. 除第一个元素以外，每个元素都有一个前驱；定义：n个相同数据元素组成的有限的序列；3. 一对一的关系；
C语言---静态创建顺序表及定义、插入、删除操作
XHR74138的博客
06-28 1395
题目：创建一个静态的顺序表存放整数，大小为10，完成以下操作：（1）输入6个整数，并输出顺序表内容，并显示剩余空间个数（2）在顺序表的第3个位置插入0，并输出顺序表内容，并显示剩余空间个数（3）在顺序表的第11个位置插入0，显示为非法（4）删除顺序表的第6个位置的整数，并输出顺序表内容，并显示剩余空间个数程序代码：#include &lt;stdio.h&gt; #include &lt;stdl...
C++ 线性表的顺序存储：顺序表(静态)
01-06
//创建顺序表 void PrintList(sqList L);//打印顺序表 void InsertElem(sqList &L,int i,int e);//插入元素 void DeleteElem(sqList &L,int i,int &e);//删除元素 int LocateElem(sqList L,int e);//查询是否有值为e...
数据结构c++代码（顺序表的代码，包括静态顺序表和动态顺序表）
07-13
静态顺序表的优点在于空间利用率高，因为其大小在创建时已经确定，不会因为空间分配和释放而产生额外开销。然而，它的缺点是当预设的容量不足时，无法直接添加新元素，需要重新创建一个更大的数组并转移已有元素，这...
c代码-顺序表-动态分配
07-16
为了解决这个问题，我们通常使用动态分配来创建可变大小的顺序表。 在C语言中，动态内存分配主要依赖于`malloc()`，`calloc()`，`realloc()`和`free()`这四个函数。`malloc()`用于动态地分配指定大小的内存块，`...
c代码-静态分配内存的顺序表
07-16
在静态分配内存的顺序表中，我们通常指的是在编译时就已经预定了大小的数组。这种分配方式与动态内存分配（如使用malloc或calloc）不同，静态分配的内存空间在程序运行前就已经确定，无法在运行时改变其大小。 本文...
静态顺序表的实现
追梦的小蚂蚁
04-14 270
Seqlist.h #define _CRT_SECURE_NO_WARNINGS 1 #pragma once #include&lt;stdio.h&gt; #include&lt;assert.h&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&gt; #define MAX_SIZE 10 typedef int DataType;...
静态创建、初始化一个顺序表
一个随时准备弃坑的博客
03-18 962
静态创建、初始化一个顺序表 #include<stdio.h> #define MaxSize 10 //定义最大长度 typedef struct { int data[MaxSize];//用静态的数组存放数据元素 int length;//顺序表当前长度 }SqList; //顺序表类型定义 //基本操作——初始化一个顺序表 void InitList(SqList &L...
静态数组顺序表
adorable_的博客
12-05 696
实现基于静态数组的顺序表的以下基本操作: 1. 初始化 2. 尾插 3. 尾删 4. 头插 5. 头删 6. 读任意位置元素 7. 修改任意位置元素 8. 查找指定元素值的下标 9. 在任意位置插入元素 实现在顺序表中增删查改需注意以下几点：   1.初始化时不用将所有元素赋值为0，那样会降低代码效率   2....
c语言数据结构之顺序表静态链表的创建及功能函数
A8888006的博客
11-03 763
#include "stdio.h" #include "stdlib.h"#define ERROR 0 #define OK 1 #define FALSE 0 #define TRUE 1 #define MAXSIZE 1000typedef int ElemType ; typedef int Status ;/创建一个静态链表/typedef struct { ElemType
数据结构之静态顺序表
skrskr66的博客
11-11 744
title: 数据结构之静态顺序表 date: 2018-11-09 14:21:51 tags: C-数据结构 静态顺序表属于数据结构开始的一种基本结构 首先我们要知道数据结构的概念 数据结构 数据的组织关系 算法 为了达到特定的目的的一系列过程。在这个过程中又分为两种角度 1） 逻辑角度：线性结构，树形结构，图形结构 2） 存储角度：顺序存储，链式存储 在线性结构中顺序存储的方式，在本...
数据结构顺序表——静态数组的创建
Prescu的博客
05-04 385
//创建静态顺序表 #include<stdio.h> #define Maxsize 10 //表的最大长度为10 typedef struct{ int data[Maxsize]; int length; }Sqlist; void InitList(Sqlist &L){ for(int i=0;i<Maxsize;i++) { //使所有元素默认为0，防止...
顺序表的实现（C语言）
qq_931027577
12-07 257
线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 1.顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般...
数据结构——静态线性表操作（顺序表）
programmer1997的博客
03-21 1350
静态线性表 #define ListSize 100 //最大允许长度 typedef struct { ListData data[ListSize] ; //存储空间 int length; //当前元素个数 } SeqList; // 1. InitList(&amp;...
C++实现静态数组顺序表操作详解
1. **初始化** (seqlistInit)：创建一个空的顺序表，将size设置为0，表示数组中没有元素。 2. **尾插** (seqlistPushBack)：在顺序表的末尾添加一个元素，增加size的值，并将新元素存入数组的相应位置。 3. **尾删...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值