数据结构 —— 第一个程序 【顺序表】

最新推荐文章于 2024-04-21 22:06:18 发布
最新推荐文章于 2024-04-21 22:06:18 发布
阅读量916 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： 算法与有趣代码--记录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chenzhenyu123456/article/details/48715199
本文详细介绍了如何初始化、查询、扩容、插入、清空、删除、合并顺序表的操作流程，包括冒泡排序、输入输出、元素定位、删除、插入、合并等关键步骤。

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


顺序表的初始化、查询、扩容、插入、清空、删除、合并。



//操作的开始***********************************
//操作的进行
//操作的结束***********************************
#include <cstdio>
#include <cstring>
#include <algorithm>
#define MAX 1000
#define MAXM 10
#define OK 1
#define OVERFLOW -1
#define ERROR -2
#define ListAdd 10//顺序表扩容
#define ListInitsize 20//顺序表初始化尺寸
using namespace std;
typedef int Status;
typedef int ElemType;
typedef struct
{
    ElemType *elem;
    ElemType length;
    ElemType listsize;
}SqList;
SqList La, Lb, Lc;
void Sort(SqList &L)//冒泡排序
{
    for(int i = 0; i < L.length; i++)
        for(int j = 0; j < i; j++)
            if(L.elem[i] < L.elem[j])
            {
                int t = L.elem[i];
                L.elem[i] = L.elem[j];
                L.elem[j] = t;
            }
}
void Listinput(SqList &L)
{
    printf("*******************************************************************************\n");
    L.elem = (ElemType *)malloc(ListInitsize * sizeof(ElemType));
    if(!L.elem) exit(OVERFLOW);
    L.length = 0;
    L.listsize = ListInitsize;
    printf("\t\t\t\t输入元素个数\n");
    printf("\t\t\t\t");
    int n; scanf("%d", &n);
    printf("\t\t\t\t输入元素\n");
    printf("\t\t\t\t");
    for(int i = 0; i < n; i++)
        scanf("%d", &L.elem[i]);
    L.length = n;
    Sort(L);
    printf("*******************************************************************************\n");
}
void ListClear(SqList &L){
    printf("*******************************************************************************\n");
    L.length = 0;
    printf("*******************************************************************************\n");
}
void ListQuery(SqList &L)
{
    printf("*******************************************************************************\n");
    printf("\t\t\t\t输入要查询元素的位置\n");
    printf("\t\t\t\t");
    int op; scanf("%d", &op);
    if(op < 1 || op > L.length)//判断位置是否合法
    {
        printf("\t\t\t\t查询位置不合法\n");
        printf("*******************************************************************************\n");
    }
    else
    {
        printf("\t\t\t\t%d\n", L.elem[op-1]);
        printf("*******************************************************************************\n");
    }
}
void ListDelete(SqList &L)
{
    printf("*******************************************************************************\n");
    printf("\t\t\t\t输入要删除元素的位置\n");
    printf("\t\t\t\t");
    int op; scanf("%d", &op);
    if(op < 1 || op > L.length)//判断位置是否合法
    {
        printf("\t\t\t\t删除位置不合法\n");
        printf("*******************************************************************************\n");
    }
    int *p, *q;
    q = &(L.elem[L.length-1]);
    p = &(L.elem[op-1]);
    int x = *p;//存储删除的元素
    for(; p <= q; p++)
        *p = *(p+1);
    --L.length;
    printf("*******************************************************************************\n");
}
void ListInsert(SqList &L)
{
    printf("*******************************************************************************\n");
    printf("\t\t\t\t输入要插入元素的位置\n");
    printf("\t\t\t\t");
    int op; scanf("%d", &op);
    if(op < 1 || op > L.length+1)//判断位置是否合法
    {
        printf("\t\t\t\t插入位置不合法\n");
        printf("*******************************************************************************\n");
    }
    //扩容操作
    int *newbase;
    if (L.length >= L.listsize)
    {
        newbase = (ElemType *)realloc(L.elem, (L.listsize+ListAdd)*sizeof(ElemType));
        if(!newbase) exit(OVERFLOW); // 存储分配失败
        L.elem = newbase;         // 新基址
        L.listsize += ListAdd; // 增加存储容量
    }
    printf("\t\t\t\t输入要插入的元素\n");
    printf("\t\t\t\t");
    int x; scanf("%d", &x);
    int *p, *q;
    q = &(L.elem[op-1]);
    for(p = &(L.elem[L.length-1]); p >= q; p--)
        *(p+1) = *p;
    *q = x;
    ++L.length;
    printf("*******************************************************************************\n");
}
void ListMerge(SqList &La, SqList &Lb, SqList &Lc)
{
    printf("*******************************************************************************\n");
    printf("\t\t\t\t要合并的顺序表\n");
    printf("\t\t\t\t顺序表a和顺序表b合并成顺序表c\n");
    int *pa, *pb, *pc;
    pa = La.elem;  pb = Lb.elem;
    Lc.listsize = Lc.length = La.length+Lb.length;  //Lc的长度赋值
    pc = Lc.elem = (ElemType *)malloc(Lc.listsize*sizeof(ElemType));
    if(!Lc.elem)  exit(OVERFLOW); //分配空间
    int *pa_last = La.elem + La.length - 1; //记录La最后元素存放地址
    int *pb_last = Lb.elem + Lb.length - 1; //记录Lb最后元素存放地址
    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++;
    printf("*******************************************************************************\n");
}
void ListPrintf(SqList &L)
{
    printf("*******************************************************************************\n");
    printf("\t\t\t\t元素如下:\n");
    if(L.length == 0)
    {
        printf("\t\t\t\t顺序表为空\n");
        printf("*******************************************************************************\n");
    }
    int *p, *q;
    p = &(L.elem[0]);
    q = &(L.elem[L.length-1]);
    printf("\t\t\t\t");
    for(; p <= q; p++)
        printf("%d ", *p);
    printf("\n");
    printf("*******************************************************************************\n");
}
void Read_How_To_Use()
{
	printf("****************************使用前请您阅读——使用指南**************************\n");
	printf("***********************函数Listinput() —— 输入顺序表元素**********************\n");
	printf("***********************函数ListQuery() —— 查询顺序表元素**********************\n");
	printf("***********************函数ListDelete() —— 删除顺序表元素*********************\n");
	printf("***********************函数ListInsert() —— 插入顺序表元素*********************\n");
	printf("***********************函数ListClear() —— 清空顺序表元素**********************\n");
	printf("***********************函数ListPrintf() —— 输出顺序表元素*********************\n");
	printf("***********************函数ListMerge() —— 合并两个顺序表**********************\n");
	printf("*********************************返回上一步请输入0****************************\n");
}
void Chooseoperator(int kind, int op)
{
    int C;
    switch(op)
    {
        case 1:
                printf("\n\n\n");
                printf("\t\t\t\t请选择操作:\n");
                printf("\t\t\t\t1: 使用说明\n");
                printf("\t\t\t\t2: 开始使用\n");
                printf("\t\t\t\t3: 退出系统\n");
                printf("\t\t\t\t您的选择:");
                scanf("%d", &C);
                while(C < 1 || C > 3)
                {
                    printf("\t\t\t\t输入不合法，请重新输入\n");
                    printf("\t\t\t\t");
                    scanf("%d", &C);
                }
                switch(C)
                {
                    case 1: system("cls"); Read_How_To_Use();
                            printf("\t\t\t\t您的选择:");
                            scanf("%d", &C);
                            while(C != 0)
                            {
                                printf("\t\t\t\t");
                                printf("输入不合法，请重新输入\n");
                                printf("\t\t\t\t您的选择:");
                                scanf("%d", &C);
                            }Chooseoperator(1, 1); break;
                    case 2: system("cls"); Chooseoperator(1, 2); break;
                    case 3: printf("\t\t\t\t谢谢使用！\n"); exit(0);
                }
                break;

        case 2:
                printf("\n\n\n");
                printf("\t\t\t\t对链表进行操作，请选择:\n");
                printf("\t\t\t\t1: 顺序表a\n");
                printf("\t\t\t\t2: 顺序表b\n");
                printf("\t\t\t\t3: 顺序表c\n");
                printf("\t\t\t\t4: 把顺序表a和顺序表b合并成顺序表c\n");
                printf("\t\t\t\t5: 回退上一步\n");
                printf("\t\t\t\t您的选择:");
                scanf("%d", &C);
                while(C < 1 || C > 5)
                {
                    printf("\t\t\t\t输入不合法，请重新输入\n");
                    printf("\t\t\t\t您的选择:");
                    scanf("%d", &C);
                }
                if(C == 5)
                {
                    Chooseoperator(1, 1);
                    break;
                }
                system("cls");
                Chooseoperator(C, 3);
                break;

        case 3:
                printf("\n\n\n");
                printf("\t\t\t\t选择操作:\n");
                printf("\t\t\t\t1: 输入元素\n");
                printf("\t\t\t\t2: 查询元素\n");
                printf("\t\t\t\t3: 删除元素\n");
                printf("\t\t\t\t4: 插入元素\n");
                printf("\t\t\t\t5: 清空顺序表\n");
                printf("\t\t\t\t6: 输出顺序表\n");
                printf("\t\t\t\t7: 合并顺序表\n");
                printf("\t\t\t\t8: 回退上一步\n");
                printf("\t\t\t\t您的选择:");
                scanf("%d", &C);
                while(C < 1 || C > 8)
                {
                    printf("\t\t\t\t输入不合法，请重新输入\n");
                    printf("\t\t\t\t您的选择:");
                    scanf("%d", &C);
                }
                switch(C)
                {
                    case 1: system("cls");
                            switch(kind)
                            {
                                case 1: Listinput(La); break;
                                case 2: Listinput(Lb); break;
                                case 3: Listinput(Lc);
                            }
                            Chooseoperator(kind, 3); break;
                    case 2: system("cls");
                            switch(kind)
                            {
                                case 1: ListQuery(La); break;
                                case 2: ListQuery(Lb); break;
                                case 3: ListQuery(Lc);
                            }
                            Chooseoperator(kind, 3); break;
                    case 3: system("cls");
                            switch(kind)
                            {
                                case 1: ListDelete(La); break;
                                case 2: ListDelete(Lb); break;
                                case 3: ListDelete(Lc);
                            }
                            Chooseoperator(kind, 3); break;
                    case 4: system("cls");
                            switch(kind)
                            {
                                case 1: ListInsert(La); break;
                                case 2: ListInsert(Lb); break;
                                case 3: ListInsert(Lc);
                            }
                            Chooseoperator(kind, 3); break;
                    case 5: system("cls");
                            switch(kind)
                            {
                                case 1: ListClear(La); break;
                                case 2: ListClear(Lb); break;
                                case 3: ListClear(Lc);
                            }
                            Chooseoperator(kind, 3); break;
                    case 6: system("cls");
                            switch(kind)
                            {
                                case 1: ListPrintf(La); break;
                                case 2: ListPrintf(Lb); break;
                                case 3: ListPrintf(Lc);
                            }
                            Chooseoperator(kind, 3); break;
                    case 7: system("cls"); ListMerge(La, Lb, Lc); Chooseoperator(1, 2); break;
                    case 8: system("cls"); Chooseoperator(1, 2);
                }
    }
}
int main()
{
    printf("*******************************您好，欢迎使用本系统*****************************\n\n");
    Chooseoperator(1, 1);
	return 0;
}


数据结构Python版（一）——顺序表
⚡
06-14 5774
线性表就是数据元素的排列像一条线一样的表。线性表严格的定义是具有相同特性的数据元素组成的一个有限序列。其特征有3个：不同于集合，线性表中可以出现值相同的元素。线性表的逻辑结构一般表示为 (a0,a1,⋯ ,an−1)(a_0,a_1,\cdots,a_{n-1})(a0​,a1​,⋯,an−1​)，用 n(n≥0)n(n\geq0)n(n≥0) 表示线性表的长度（即线性表中元素的个数）。当 n=0n=0n=0 时，表示线性表是一个空表，不包含任何数据元素。线性表的逻辑特征：每个元素最多只有一个前驱元素，也最
数据结构顺序表基本流程
采菊东篱下，Python满乾坤！
11-13 4368
生活中很多事物是有顺序关系的，如班级座位从前到后是按排的顺序，从左到右是按列的顺序，可以很方便的定位到某一个位置，但如果座位是散乱的，就很难定位。 在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。 对于这种需求，最简单的解决方案便是将这样一组元素看成一个序
数据结构程序
weixin_44666472的博客
03-07 324
#include<stdio.h> int main() { int n,i=0; scanf("%d",&n); int num[100001]={0,0,}; while(n-->0) scanf("%d",&num[i++]); if(i==1) { printf("%d",num[0]); ...
我学的第一个《数据结构与算法》的程序
NicolasHe的专栏
09-07 734
康老师在机房教的，虽然没有书，但是还是认真的听着，老师讲的也很是仔细。申请一个动态内存，定义一个动态的数组。实际上就是生成一个线性表。#include #include using namespace std; #define ok 1 typedef struct { int *p;//=(int *)malloc(10*sizeof(int)); int size; i
408数据结构——线性表之C++实现顺序表
long99920的博客
05-22 625
可修改main函数内的注释，测试相应的顺序表操作。 #include <iostream> using namespace std; #define initSize 10 // 顺序表初始容量 // 创建顺序线性表(顺序表),动态分配内存空间地址 typedef struct { int *array; // 指向顺序表的指针 int maxSize,length; // 顺序表最大容量,顺序表当前长度 }sqList;
数据结构——顺序表的应用——通讯录
最新发布
2301_80745587的博客
04-21 1025
数据结构——顺序表的应用——通讯录
考研数据结构——线性表（顺序表&链表）最全！含代码！
给你糖ya的博客
03-20 1814
和顺序表相比，单链表是链式存储而不是顺序存储，即在内存中是离散存储的，每个结点除了存放数据元素外还要存放指向下一个节点的指针；不需要大片连续空间，改变容量方便；但是不可随机存取，要耗费一定空间存放指针。typedef struct DNode { //定义单链表的结点类型int data;//每个结点存放一个数据元素//prior指向前驱结点，next指向后继结点单链表的各个结点离散地分布在内存中的各个地方；静态链表会分配一整块连续的内存空间来存放各个结点，各个结点不一定连续但都在这一块内存中。
python数据结构——顺序表
fyire的博客
08-15 786
1. 顺序表的定义 数据元素连续存储，并且每个元素的存储空间大小相同，元素下标是逻辑地址，元素的物理地址可通过存储区的起始地址加上逻辑地址和存储单元大小来确定。 2. 顺序表的优点 由于元素的物理地址可通过存储区的起始地址加上逻辑地址和存储单元大小来确定，因此要访问一个元素不用做遍历操作，只需给定逻辑地址就可是实现访问。 计算物理地址的公式如下： 其中表示逻辑地址，表示第 给元素，表示存储区的起始地址， 表示每个元素存...
数据结构程序.docx
07-11
数据结构程序 数据结构程序全文共10页，当前为第1页。数据结构程序全文共10页，当前为第1页。PSeqList createNullList_seq(int m) 数据结构程序全文共10页，当前为第1页。 数据结构程序全文共10页，当前为第1页。 { PSeqList palist = (PSeqList)malloc(sizeof(struct SeqList)); if (palist != NULL) { palist->element = (DataType*)malloc(sizeof(DataType)*m); if (palist->element) { palist->MAXNUM=m; palist ->n = 0; return (palist); } else free (palist); } printf("Out of space!!!\n"); return NULL; } int insertPre_seq(PSeqList palist, int p, DataType x) { int q; if ( palist->n >= palist-> MA
数据结构最全源程序
09-27
里面有数据结构中的所有程序而且全都可以直接使用！ 042 插入排序 043 希尔排序 044 冒泡排序 045 快速排序 046 选择排序 047 堆排序 048 归并排序 049 基数排序 050 二叉搜索树操作 051 二项式系数递归 052 背包问题 053 顺序表插入和删除 054 链表操作（1） 055 链表操作（2） 056 单链表就地逆置 057 运动会分数统计 058 双链表 059 约瑟夫环 060 记录个人资料 061 二叉树遍利 062 浮点数转换为字符串 063 汉诺塔问题 064 哈夫曼编码 065 图的深度优先遍利 066 图的广度优先遍利 067 求解最优交通路径 068 八皇后问题 069 骑士巡游 070 用栈设置密码 071 魔王语言翻译 072 火车车厢重排 073 队列实例 074 K阶斐波那契序列
数据结构中部分流程图
01-02
前序递归，前序非递归，中序递归，中序非递归等等7个流程图。
数据结构源代码,一些常用的数据结构程序，C语言版
11-16
数据结构源代码，一些常用的数据结构程序，C语言版
数据结构与算法-顺序表
olunano的博客
01-27 394
文章目录2.顺序表2.1顺序表的基本形式 2.顺序表   在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。   对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种有意义的信息，或者表示数据之间的某种关系。   这样的一组序列元素的组织形式，我们可以将其抽象为线性表。一个线性表是某类元素的一个集合，还记录着元素之
数据结构-程序设计
m0_58321769的博客
05-18 1956
数据结构-程序设计项目1：中国计算机设计大赛赛事统计项目2：校园导游咨询项目3：算术表达式求解 项目1：中国计算机设计大赛赛事统计 一、问题描述： 参加计算机设计大赛的n个学校编号为1n,赛事分成m个项目，项目的编号为1m.比赛获奖按照得分降序，取前三名，写一个统计程序产生各种成绩单和得分报表。 二、基本要求： 1）每个比赛项目至少有10支参赛队；每个学校最多有6支队伍参赛; 2）能统计各学校的总分; 3）可以按照学校编号或名称，学校的总分、各项目的总分排序输出； 4）可以按学校编号查询学校某个项目的获奖情
C语言数据结构(2)--VS2015下第一个C语言程序
程序员大阳
09-20 806
0 背景 因为大家用的开发环境各不相同，所以此处演示下VS2015下C语言项目开发流程。 1 下载安装VS2015 这个就不具体展开介绍了，反正VS系列的软件都是傻瓜式的下一步下一步安装即可。下载安装的时候直接使用社区办(community)就足够了，做好心理准备，时间很长哦。。。 此处还是给一个VS2015社区版的种子便于大家快速下载：ed2k://|file|cn_visual_studio_...
数据结构c语言相关程序,数据结构(C语言实现)
weixin_31143059的博客
05-18 328
1.线性表的顺序存储#include#include#define MAX 20typedef int DataType ;typedef struct{int length;DataType data[MAX];}SqList;int InitList(SqList *L){//L=(SqList *)malloc(sizeof(SqList));L->length=0;return 0;...
C++编程：数据结构课后习题详解——顺序表与链表操作
- 第四题中，向顺序表中插入元素平均需要移动`(n+1)/2`个元素，127个元素移动平均值约为63.5，选B。 - 第五题链接存储（链表）的存储空间包括每个节点的存储空间以及指向下一个节点的指针，所以空间占用不是固定的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值