数据结构【线性表篇】(一）

news2025/4/23 1:17:26

数据结构【线性表篇】(一）

文章目录

  • 数据结构【线性表篇】(一）
  • 前言
      • 为什么突然想学算法了？
      • 为什么选择码蹄集作为刷题软件？
  • 目录
  • 一、顺序表
    • (一)、顺序表的定义
    • (二)、顺序表的插入删除
    • (三)、顺序表的查找
  • 二、完整代码
    • (一)、顺序表的增删改查-完整代码(静态存储)
    • (二)、顺序表的增删改查-完整代码(动态存储)
  • 三、结语

前言

在这里插入图片描述

为什么突然想学算法了？

> 用较为“官方”的语言讲，是因为算法对计算机科学的所有分支都非常重要。 在绝大多数的计算机科学分支领域中，要想完成任何实质性的工作，理解算法的基础知识并掌握与算法密切相关的数据结构知识是必不可少的。
> 但从实际而言，是因为当下竞争压力逐渐增大，无论走哪一条路，都不免需要一些相对丰富的算法知识，是故，便产生了一个寒假巩固速成算法的计划，可能对于像我这种算法竞赛小白而言，几乎很难，但我仍然还是想尝试一下，毕竟，梦想还是要有的，万一实现了呢？～(￣▽￣～)~

在这里插入图片描述

为什么选择码蹄集作为刷题软件？

码蹄集，是在全国高等学校计算机教学与产业实践资源建设专家委员会(TIPCC) 指导下建设的，其依托全国各大名校计算机系和清华大学出版社等单位的强大资源，旨在为计算机学习爱好者提供全面和权威的计算机习题。
.
在这里插入图片描述

目录

一、顺序表

(一)、顺序表的定义

参考代码

//顺序表的定义
typedef struct{
    int num;        //号数
    int people;      //人数
}Customer;

//顺序表的实现——静态分配
#define Maxsize 10          //定义最大长度
typedef struct{
    int data[Maxsize];       //用静态的“数组”存放数据元素
    int length;             //顺序表的当前长度
}SqList;                   //顺序表的类型定义(静态分配方式) sequence:顺序，序列

//顺序表的实现——动态分配
#define InitSize 10           //定义最大长度
typedef struct{
    int *data;               //指示动态分配数组的指针
    int MaxSize;            //顺序表的最大容量
    int length;              //顺序表的当前长度
}SeqList;                   //顺序表的类型定义(动态分配方式)

//key: 动态申请和释放内存空间
//C -- malloc、free函数
//       L.data = (ElemType*)malloc(sizeof(ElemType)*InitSize)
//  ElemType*: malloc函数返回一个指针，需要强制转型为你定义的数据元素类型指针
//  InitSize:  malloc函数的参数，指明要分配多大的连续内存空间
//C++ -- new、delete关键字

//基本操作——初始化一个程序表(静态分配)
void InitList(SqList &L){
    for(int i=0;i<L.length;i++)
        L.data[i]=0;        //将所有数据元素设置为默认初始值
    L.length=0;             //顺序表初始长度为0
}

//基本操作——初始化一个程序表(动态分配)
void InitList(SeqList &L){
    //用malloc函数申请一片连续的存储空间
    L.data = (int*) malloc(InitSize*sizeof(int));
    for(int i=0;i<L.length;i++)
        L.data[i]=0;        //将所有数据元素设置为默认初始值
    L.length=0;
    L.MaxSize=InitSize;
}

//增加动态数组的长度
void IncreaseSize(SeqList &L,int len){
    int *p=L.data;
    L.data=(int*) malloc((L.MaxSize+len)*sizeof(int));
    for(int i=0;i<L.length;i++){
        L.data[i]=p[i];      //将数据复制到新区域
    }
    L.MaxSize=L.MaxSize+len; //顺序表最大长度增加len
    free(p);                 //释放原来的内存空间
}

//输出顺序表
void printList(SqList &L){
    printf("当前顺序表的值依次为：\n");
    for(int i=0;i<L.length;i++){
        printf("%d\n",L.data[i]);
    }
    printf("\n");
}

int main(){
    SqList sqList;           //声明一个顺序表(静态)
    InitList(sqList);          //初始化顺序表(静态)
//----------------------------------------------------
    SeqList seqList;        //声明一个顺序表(动态)
    InitList(seqList);   //初始化顺序表(动态)
    return 0;
}

(二)、顺序表的插入删除

//顺序表的基本操作(以下方法均为静态，动态方法与之类似)
//插入(在表L中的第i个位置上插入指定元素e)
bool ListInsert(SqList &L,int i,int e){
    if(i<1 || i>L.length+1)      //判断i的范围是否有效
        return false;
    if(L.length>=Maxsize)        //当前存储空间已满，不能插入
        return false;
    for(int j=L.length;j>=i;j--) //将第i个元素及之后的元素后移
        L.data[j]=L.data[j-1];
    L.data[i-1]=e;               //在位置i处放入e
    L.length++;
    return true;
} //平均时间复杂度=O(n)

//删除(删除表L中第i个位置的元素，并用e返回删除元素的值)
bool ListDelete(SqList &L,int i,int &e){
    if(i<1 || i>L.length)       //判断i的范围是否有效
        return false;
    e=L.data[i-1];              //将被删除的元素赋值给e
    for(int j=i;j<L.length;j++) //将第i个位置后的元素前移
        L.data[j-1]=L.data[j];
    L.length--;                 //线性表长度减1
    return true;
}//平均时间复杂度=O(n)

int main(){
    SqList sqList;           //声明一个顺序表(静态)
    InitList(sqList);     //初始化顺序表(静态)

    //插入操作——在位置i处插入元素e
    ListInsert(sqList,1,3);
    ListInsert(sqList,2,4);
    ListInsert(sqList,2,1);
    printList(sqList);

    //删除操作
    int e=-1;                //用变量e把删除的元素“带回来”
    if(ListDelete(sqList,1,e))
        printf("已删除第1个元素，删除元素值为%d\n",e);
    else
        printf("位序i不合法，删除失效\n");
    printList(sqList);

    //查找操作
    int a=LocateElem(sqList,4); //按值查找
    int b=GetElem(sqList,2);     //按位查找
printf("%d %d",a,b);

//----------------------------------------------------
    SeqList seqList;        //声明一个顺序表(动态)
    InitList(seqList);   //初始化顺序表(动态)
    // 在顺序表中随便插入几个元素
    IncreaseSize(seqList,5);

    return 0;
}

(三)、顺序表的查找

//查找(静态)
//按位查找
int GetElem(SqList L,int i){ //获取表L中的第i个位置的元素的值
    return L.data[i-1];
} //时间复杂度O(1)

//按值查找
//在顺序表L中查找第一个元素值等于e的元素，并返回其位序
int LocateElem(SqList L,int e){
    for(int i=0;i<L.length;i++)
        if(L.data[i]==e)
            return i+1;     //数组下标为i的元素值等于e，返回其为序i+1
    return 0;               //退出循环，说明查找失败
} //时间复杂度O(n)

//查找(动态)
//按位查找
int GetElem(SeqList L,int i){ //获取表L中的第i个位置的元素的值
    return L.data[i-1];
}

//按值查找
//在顺序表L中查找第一个元素值等于e的元素，并返回其位序
int LocateElem(SeqList L,int e){
    for(int i=0;i<L.length;i++)
        if(L.data[i]==e)
            return i+1;     //数组下标为i的元素值等于e，返回其为序i+1
    return 0;               //退出循环，说明查找失败
}

二、完整代码

(一)、顺序表的增删改查-完整代码(静态存储)

#include<iostream>
using namespace std;

//定义顺序表的静态存储结构
#define Maxsize 10
typedef struct{
    int data[Maxsize];
    int length;
}SqList;

//初始化顺序表
void InitSqList(SqList &L){
    for(int i=0;i<Maxsize;i++){
        L.data[i]=0;
    }
    L.length=0;
}

//在顺序表位置i处插入元素e
bool InsertSqList(SqList &L,int i,int e){
    if(i<1 || i>L.length+1) return false;
    if(L.length >= Maxsize) return false;
    for(int j=L.length;j>i;j--){
        L.data[j]=L.data[j-1];
    }
    L.data[i-1]=e;
    L.length++;
    return true;
}

//在顺序表位置i处删除元素e
bool DeleteSqList(SqList &L, int i, int &e){
    if(i<1 || i>L.length+1) return false;
    e = L.data[i-1];
    for(int j=i;j<L.length;j++){
        L.data[j-1]=L.data[j];
    }
    L.length--;
    return true;
}

//修改顺序表位置i处元素
bool ChangeSqList(SqList &L, int i,int e){
    if(i<1 || i>L.length+1) return false;
    L.data[i-1]=e;
    return true;
}

//查找顺序表位置i处元素
bool FindLoacteSqList(SqList &L,int i,int &e){
    if(i<1 || i>L.length+1) return false;
    e = L.data[i-1];
    return true;
}

//查找元素e在顺序表中的位置
bool FindElemSqList(SqList &L,int &i, int e){
    for(int j=0;j<L.length;j++){
        if(L.data[j]==e){
            i=j+1;
            return true;
        }
    }
    return false;
}

//输出顺序表
void PrintfSqList(SqList L){
    for(int i=0;i<L.length;i++)
        cout<<L.data[i]<<" ";
}


int main(){
    SqList L;
    InitSqList(L);

    for(int i=1;i<=10;i++){
        InsertSqList(L,i,i);
    }
    PrintfSqList(L);
    cout<<endl;

    //删除i处元素e
    cout<<"删除i处元素e"<<endl;
    int e;
    cout<<DeleteSqList(L,3,e)<<endl;
    cout<<e<<endl;
    PrintfSqList(L);
    cout<<endl<<endl;

    //修改位置i处元素e
    cout<<"修改位置i处元素e"<<endl;
    cout<<ChangeSqList(L,4,10)<<endl;
    PrintfSqList(L);
    cout<<endl<<endl;

    //查找
    //查找位置i处元素e
    cout<<"查找位置i处元素e"<<endl;
    cout<<FindLoacteSqList(L,4,e)<<endl;
    cout<<e<<endl<<endl;

    //查找元素e的位置
    int i;
    cout<<"查找元素e的位置"<<endl;
    cout<<FindElemSqList(L,i,10)<<endl;
    cout<<i<<endl;

    return 0;
}

(二)、顺序表的增删改查-完整代码(动态存储)

#include<iostream>
using namespace std;
#define Maxsize 10

//顺序表的动态存储
typedef struct{
    int *data;          //指向动态开辟的数组
    int length;         //有效数据个数
    int Size;           //容量空间的大小
}SqList;

//初始化顺序表
//基本操作——初始化一个程序表(动态分配)
void InitSqList(SqList &L){
    //用malloc函数申请一片连续的存储空间
    L.data =(int*)malloc(Maxsize * sizeof(int));
    L.length=0;
    L.Size=Maxsize;
}

//增加动态数组的长度
void IncreaseSize(SqList &L,int len){
    int *p=L.data;
    L.data=new int(Maxsize+len);
    for(int i=0;i<L.length;i++){
        L.data[i]=p[i];      //将数据复制到新区域
    }
    L.Size=L.Size+len; //顺序表最大长度增加len
    delete p;
}

//在顺序表位置i处插入元素e
bool InsertSqList(SqList &L,int i,int e){
    if(i<1 || i>L.length+1) return false;
    if(L.length >= L.Size) return false;
    for(int j=L.length;j>i;j--){
        L.data[j]=L.data[j-1];
    }
    L.data[i-1]=e;
    L.length++;
    return true;
}

//在顺序表位置i处删除元素e
bool DeleteSqList(SqList &L, int i, int &e){
    if(i<1 || i>L.length+1) return false;
    e = L.data[i-1];
    for(int j=i;j<L.length;j++){
        L.data[j-1]=L.data[j];
    }
    L.length--;
    return true;
}

//修改顺序表位置i处元素
bool ChangeSqList(SqList &L, int i,int e){
    if(i<1 || i>L.length+1) return false;
    L.data[i-1]=e;
    return true;
}

//查找顺序表位置i处元素
bool FindLoacteSqList(SqList &L,int i,int &e){
    if(i<1 || i>L.length+1) return false;
    e = L.data[i-1];
    return true;
}

//查找元素e在顺序表中的位置
bool FindElemSqList(SqList &L,int &i, int e){
    for(int j=0;j<L.length;j++){
        if(L.data[j]==e){
            i=j+1;
            return true;
        }
    }
    return false;
}

//销毁顺序表
void DeleteSqList(SqList &L){
    free(L.data);
    L.data = NULL;
    L.length = L.Size = 0;
}

//输出顺序表
void PrintfSqList(SqList L){
    for(int i=0;i<L.length;i++)
        cout<<L.data[i]<<" ";
}

int main(){
    SqList L;
    InitSqList(L);

    for(int i=1;i<=10;i++){
        InsertSqList(L,i,i);
    }
    PrintfSqList(L);
    cout<<endl;

    //对动态顺序表进行扩容
    cout<<"对动态顺序表进行扩容"<<endl;
    IncreaseSize(L,10);
    cout<<"扩容后的长度为："<<L.Size<<endl;
    InsertSqList(L,11,3);
    //不能直接隔着插，如直接在19处插1，因为中间是空的，代码里的互换会出问题，需要都初始化后，才能插
    //InsertSqList(L,19,1);
    //但这样是可以的，先都初始化，然后再在19处插1
    for(int i=12;i<=18;i++) InsertSqList(L,i,i);
    InsertSqList(L,19,1);
    PrintfSqList(L);
    cout<<endl;

    //删除i处元素e
    cout<<"删除i处元素e"<<endl;
    int e;
    cout<<DeleteSqList(L,3,e)<<endl;
    cout<<e<<endl;
    PrintfSqList(L);
    cout<<endl<<endl;

    //修改位置i处元素e
    cout<<"修改位置i处元素e"<<endl;
    cout<<ChangeSqList(L,4,10)<<endl;
    PrintfSqList(L);
    cout<<endl<<endl;

    //查找
    //查找位置i处元素e
    cout<<"查找位置i处元素e"<<endl;
    cout<<FindLoacteSqList(L,4,e)<<endl;
    cout<<e<<endl<<endl;

    //查找元素e的位置
    int i;
    cout<<"查找元素e的位置"<<endl;
    cout<<FindElemSqList(L,i,10)<<endl;
    cout<<i<<endl;

    //销毁动态顺序表
    DeleteSqList(L);
    return 0;
}

三、结语

感谢大家一直以来的不断支持与鼓励，码题集题库中的进阶塔350题正在逐步更新，之后会逐步跟进星耀，王者的题，尽请期待！！！
同时，也希望这些题能帮助到大家，一起进步，祝愿每一个算法道路上的“苦行僧”们，都能够历经磨难，终成正果，既然选择了这条路，走到了这里，中途放弃，岂不是太过可惜？

另附中国计算机学会的杰出会员、常务理事轩哥博士的B站视频讲解链接https://space.bilibili.com/518554541/?spm_id_from=333.999.0.0，供大家更好的进行学习与刷题～(￣▽￣～)~

愿你的结局，配得上你一路的颠沛流离。
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1345956.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C语言-第十七周做题总结-数组2

C语言-第十七周做题总结-数组2

id&#xff1a;464 A.求矩阵各行元素之和 题目描述 本题要求编写程序&#xff0c;求一个给定的mn矩阵各行元素之和。 输入 输入第一行给出两个正整数m和n&#xff08;1≤m, n≤6&#xff09;。随后m行&#xff0c;每行给出n个整数&#xff0c;其间以空格分隔。 输出 每行…
阅读更多...
元旦档首日票房超4.69亿，“下雪场尴尬”上热搜！

元旦档首日票房超4.69亿，“下雪场尴尬”上热搜！

哇塞&#xff0c;元旦假期终于来啦&#xff01;&#x1f389;在这个喜庆的时刻&#xff0c;电影院也热闹非凡&#xff0c;据猫眼专业版数据显示&#xff0c;截至12月30日&#xff0c;2023年元旦档首日票房竟然超过了4.69亿&#xff01;这简直是个天文数字啊&#xff01;&#x…
阅读更多...
【GOLANG】使用插件 Goanno 的方式来对方法、接口、结构体注释模板配置

【GOLANG】使用插件 Goanno 的方式来对方法、接口、结构体注释模板配置

直接 使用插件 Goanno 的方式来对方法、接口、结构体注释模板配置 1、简单安装 Goanno 插件 File->Settings->Plugins , 搜索 Goanno Normal Method 配置内容如下&#xff1a; // Title ${function_name} // Description ${todo} // Author mumu ${date} ${time} // Par…
阅读更多...
【c语言】飞机大战2

【c语言】飞机大战2

1.优化边界问题 之前视频中当使用drawAlpha函数时&#xff0c;是为了去除飞机后面变透明&#xff0c;当时当飞机到达边界的时候&#xff0c;会出现异常退出&#xff0c;这是因为drawAlpha函数不稳定&#xff0c;昨天试过制作掩码图&#xff0c;下载了一个ps,改的话&#xff0c…
阅读更多...
黑马程序员SSM框架-SpringBoot

黑马程序员SSM框架-SpringBoot

SpringBoot简介 入门程序 也可以基于官网创建项目。 SpringBoot项目快速启动 下面的插件将项目运行所需的依赖jar包全部加入到了最终运行的jar包中&#xff0c;并将入口程序指定。 SpringBoot概述 基础配置 配置文件格式 自动提示消失解决方案。将新建的配置文件加入到配置文…
阅读更多...
Baumer工业相机堡盟工业相机如何通过NEOAPI SDK设置相机的固定帧率（C++）

Baumer工业相机堡盟工业相机如何通过NEOAPI SDK设置相机的固定帧率（C++）

Baumer工业相机堡盟工业相机如何通过NEOAPI SDK设置相机的固定帧率&#xff08;C&#xff09; Baumer工业相机Baumer工业相机的固定帧率功能的技术背景CameraExplorer如何查看相机固定帧率功能在NEOAPI SDK里通过函数设置相机固定帧率 Baumer工业相机通过NEOAPI SDK设置相机固定…
阅读更多...
使用anaconda创建notebook工程

使用anaconda创建notebook工程

1.由于每个工程使用的环境都可能不一样&#xff0c;因此一个好的习惯就是不同的工程都创建属于自己的环境&#xff0c;在anaconda中默认的环境是base&#xff1a; //括号中名字&#xff0c;代表当前的环境 (base)dragonmachine: $ conda create --nameexample2.激活环境 // 环…
阅读更多...
Python 编辑器pycharm下载与安装

Python 编辑器pycharm下载与安装

使用python语言编程&#xff0c;可以使用pycharm或者sublime等编辑器。 我这里选择pycharm编辑器。 1、下载 登录官网&#xff1a;JetBrains: Essential tools for software developers and teams 点击【Developer Tools】菜单按钮&#xff0c;可以直接找到pycharm&#xff…
阅读更多...
高斯泼溅的全面概述

高斯泼溅的全面概述

一、说明 高斯泼溅是一种用于表示 3D 场景和渲染新颖视图的方法&#xff0c;在“实时辐射场渲染的 3D 高斯泼溅”中引入。它可以被认为是 NeRF 类模型的替代品&#xff0c;就像当年的 NeRF 一样&#xff0c;高斯分布导致了许多新的研究工作&#xff0c;这些工作选择将其用作各种…
阅读更多...
鸿蒙 Window 环境的搭建

鸿蒙 Window 环境的搭建

鸿蒙操作系统是国内自研的新一代的智能终端操作系统&#xff0c;支持多种终端设备部署&#xff0c;能够适配不同类别的硬件资源和功能需求。是一款面向万物互联的全场景分布式操作系统。 下载、安装与配置 DevEco Studio支持Windows系统和macOS系统 Windows系统配置华为官方推…
阅读更多...
Markdown之YAML效果图语法介绍(二十六)

Markdown之YAML效果图语法介绍(二十六)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 优质专栏&#xff1a;Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 优质专栏&#xff1a;多媒…
阅读更多...
C#进阶-IIS应用程序池崩溃的解决方案

C#进阶-IIS应用程序池崩溃的解决方案

IIS是微软开发的Web服务器软件&#xff0c;被广泛用于Windows平台上的网站托管。在使用IIS过程中&#xff0c;可能会遇到应用程序池崩溃的问题&#xff0c;原因可能有很多&#xff0c;包括代码错误、资源不足、进程冲突等。本文将为大家介绍IIS应用程序池崩溃的问题分析和解决方…
阅读更多...
缓存cache和缓冲buffer的区别

缓存cache和缓冲buffer的区别

近期被这两个词汇困扰了&#xff0c;感觉有本质的区别&#xff0c;搜了一些资料&#xff0c;整理如下 计算机内部的几个部分图如下 缓存&#xff08;cache&#xff09; https://baike.baidu.com/item/%E7%BC%93%E5%AD%98 提到缓存&#xff08;cache&#xff09;&#xff0c;就…
阅读更多...
【web安全】验证码识别-burp的captcha-killer-modified插件教程（基于百度接口）（总结一些坑）

【web安全】验证码识别-burp的captcha-killer-modified插件教程（基于百度接口）（总结一些坑）

前言 菜某分享 captcha-killer-modified插件的安装教程 整体安装教程可以看他的 安装captcha-killer-modified插件&#xff08;windospython环境&#xff09;_aptcha-killer-modified的安装-CSDN博客 但是有一点补充。 这个里面的codereg.py文件有个问题 可能是版本的问…
阅读更多...
千里马2023年终总结-android framework实战

千里马2023年终总结-android framework实战

背景&#xff1a; hi粉丝朋友们&#xff1a; 2023年马上就过去了&#xff0c;很多学员朋友也都希望马哥这边写个年终总结&#xff0c;因为这几个月时间都忙于新课程halsystracesurfaceflinger专题的开发&#xff0c;差点都忘记了这个事情了&#xff0c;今天特别花时间来写个bl…
阅读更多...
推荐系统中的 业务指标 覆盖率

推荐系统中的 业务指标 覆盖率

覆盖率&#xff08;Coverage&#xff09;是推荐系统评估指标之一&#xff0c;用于衡量推荐系统是否能够覆盖物品空间中的多样性&#xff0c;即是否能够推荐系统中的每个物品都能够被推荐给用户。覆盖率通常是一个百分比&#xff0c;表示被推荐的物品占总物品集合的比例。 覆盖…
阅读更多...
系统稳定性建设浅谈

系统稳定性建设浅谈

系统稳定性是指系统在受到外部环境变化或内部参数变化时&#xff0c;能够保持其功能和性能的稳定性。它是一种系统的性能指标&#xff0c;可以用来衡量系统的可靠性和可控性。系统稳定性的高低可以反映出系统的可靠性和可控性&#xff0c;从而为系统的设计和运行提供参考。 202…
阅读更多...
代码随想录刷题笔记（DAY4）

代码随想录刷题笔记（DAY4）

今日总结&#xff1a;今天把中心放在前端学习上&#xff0c;最后一个题没有完全理解&#xff0c;明天早起补上吧。勉强算完成任务。&#xff08;已补上&#xff09; Day 4 01. 两两交换链表中的节点&#xff08;No. 24&#xff09; 题目链接 代码随想录题解 1.1 题目 给你…
阅读更多...
jmeter安装、下载

jmeter安装、下载

JDK安装 因为Jmeter是java开发的&#xff0c;有一个特点就是得装一个java环境才能运行 需要安装一个JDK&#xff08;建议安装版本为 8,因为企业用得最多的都是在用这个版本&#xff09; 网址&#xff1a;Java Downloads | Oracle 解压下载下来的安装包&#xff0c;到自己的目…
阅读更多...
虚拟化分类和实现原理

虚拟化分类和实现原理

6、虚拟化分类 &#xff08;1&#xff09;完全虚拟化 直接将Hypervisor跑在0环内核态&#xff0c;客户机os跑在1环&#xff0c;一旦触发敏感指令&#xff0c;由0环的VMM进行捕获翻译&#xff0c;从而模 拟这些指令。而运行在1环的GuestOS永远都不知道自己是个虚拟机。是完全…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023