数据结构--顺序表

已于 2024-04-20 10:23:51 修改
阅读量135 收藏
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 c++
于 2024-04-18 17:19:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52260669/article/details/137928717
版权

顺序表

定义结构体

struct SequentialList{
    eleType *elements;
    int size;//顺序表元素个数
    int capacity;//实际容量
};

初始化顺序表

void initialilzeList(SequentialList *list,int capacity){
    //初始化数组
    //->取指针类型的成员变量
    list->elements = new eleType[capacity];//申请空间
    list->size = 0;
    list->capacity = capacity;
}

销毁顺序表

void destroyList(SequentialList *list){
    //销毁顺序表
    delete [] list->elements;//delete关键则直接删除
}

获取顺序表大小

int size(SequentialList *list){
    //获取顺序表大小
    return list->size;
}

判断顺序表是否为空

bool isEmpty(SequentialList *list){
    //判断顺序表是否为空
    return list->size == 0;
}

顺序表插入元素

void insert(SequentialList *list,int index,eleType element){
    //顺序表的插入，index表示插入位置，element表示要插入的数据
    //判断index是否合法
    if(index < 0 || index > list->size){
        throw std::invalid_argument("Invalid index");
    }
    if(list->size == list->capacity){
        //顺序表用完不能插入，需要扩容
        int newCapacity = list->capacity * 2;
        eleType *newElements = new eleType[newCapacity];
        for(int i = 0;i < list->size;++i){
            newElements[i]= list->elements[i];
        }
        delete[] list->elements;
        list->elements = newElements;
        list->capacity = newCapacity;
        
    }
    for(int i = list->size;i>index;--i){
            //顺序表index后的所有元素往后移动一个元素单位
        list->elements[i] = list->elements[i-1];
    }
    list->elements[index] = element;
    list->size++;
}

顺序表删除元素


void deleteElements(SequentialList *list,int index){
    //顺序表删除元素 index表示要删除元素的位置
    //判断index是否合法
    if(index < 0 || index >= list->size){
        throw std::invalid_argument("Invalid index");
    }
    for(int i = index;i < list->size-1;++i){
        //顺序表index后的所有元素往前移动一个元素单位
        list->elements[i] = list->elements[i+1];
    }
    list->size--;
}

顺序表查找元素下标

int findElement(SequentialList *list,eleType element){
    //查找元素下标；
    for (int i = 0; i < list->size; i++) {
        if(list->elements[i] == element){
            return i;
        }
    }
    return -1;
}

顺序表获取第index个元素

int getElement(SequentialList *list,int index){
    //获取第index个元素
    //判断index是否合法
    if(index < 0 || index >= list->size){
        throw std::invalid_argument("Invalid index");
    }
    return list->elements[index];
}

顺序表修改元素

void updateElement(SequentialList *list,int index,eleType elements){
    //修改元素
     //判断index是否合法
    if(index < 0 || index >= list->size){
        throw std::invalid_argument("Invalid index");
    }
    list->elements[index] = elements;
}

测试

int main(){
    SequentialList mylist;
    initialilzeList(&mylist,10);
    for (int i = 0; i < 10; i++) {
        insert(&mylist,i,i*10);
    }
    cout << "size:" << size(&mylist) <<endl;
    cout << "isEmpty:" << isEmpty(&mylist) <<endl;
    for (int i = 0; i < size(&mylist); i++) {
        cout << getElement(&mylist,i) << " ";
    }
    cout<<endl;
    deleteElements(&mylist,5);
    updateElement(&mylist,1,1314);
    for (int i = 0; i < size(&mylist); i++) {
        cout << getElement(&mylist,i) << " ";
    }
    cout<<endl;
    int idx = findElement(&mylist,20);
    updateElement(&mylist,idx,520);
    for (int i = 0; i < size(&mylist); i++) {
        cout << getElement(&mylist,i) << " ";
    }
    cout<<endl;
    destroyList(&mylist);
    return 0;
}

全部总结代码

#include<bits/stdc++.h>
using namespace std;
#define eleType int 
struct SequentialList{
    eleType *elements;
    int size;//顺序表元素个数
    int capacity;//实际容量
};
void initialilzeList(SequentialList *list,int capacity){
    //初始化数组
    //->取指针类型的成员变量
    list->elements = new eleType[capacity];//申请空间
    list->size = 0;
    list->capacity = capacity;
}

void destroyList(SequentialList *list){
    //销毁顺序表
    delete [] list->elements;//delete关键则直接删除
}
int size(SequentialList *list){
    //获取顺序表大小
    return list->size;
}
bool isEmpty(SequentialList *list){
    //判断顺序表是否为空
    return list->size == 0;
}
void insert(SequentialList *list,int index,eleType element){
    //顺序表的插入，index表示插入位置，element表示要插入的数据
    //判断index是否合法
    if(index < 0 || index > list->size){
        throw std::invalid_argument("Invalid index");
    }
    if(list->size == list->capacity){
        //顺序表用完不能插入，需要扩容
        int newCapacity = list->capacity * 2;
        eleType *newElements = new eleType[newCapacity];
        for(int i = 0;i < list->size;++i){
            newElements[i]= list->elements[i];
        }
        delete[] list->elements;
        list->elements = newElements;
        list->capacity = newCapacity;
        
    }
    for(int i = list->size;i>index;--i){
            //顺序表index后的所有元素往后移动一个元素单位
        list->elements[i] = list->elements[i-1];
    }
    list->elements[index] = element;
    list->size++;
}


void deleteElements(SequentialList *list,int index){
    //顺序表删除元素 index表示要删除元素的位置
    //判断index是否合法
    if(index < 0 || index >= list->size){
        throw std::invalid_argument("Invalid index");
    }
    for(int i = index;i < list->size-1;++i){
        //顺序表index后的所有元素往前移动一个元素单位
        list->elements[i] = list->elements[i+1];
    }
    list->size--;
}
int findElement(SequentialList *list,eleType element){
    //查找元素下标；
    for (int i = 0; i < list->size; i++) {
        if(list->elements[i] == element){
            return i;
        }
    }
    return -1;
}
int getElement(SequentialList *list,int index){
    //获取第index个元素
    //判断index是否合法
    if(index < 0 || index >= list->size){
        throw std::invalid_argument("Invalid index");
    }
    return list->elements[index];
}

void updateElement(SequentialList *list,int index,eleType elements){
    //修改元素
     //判断index是否合法
    if(index < 0 || index >= list->size){
        throw std::invalid_argument("Invalid index");
    }
    list->elements[index] = elements;
}
int main(){
    SequentialList mylist;
    initialilzeList(&mylist,10);
    for (int i = 0; i < 10; i++) {
        insert(&mylist,i,i*10);
    }
    cout << "size:" << size(&mylist) <<endl;
    cout << "isEmpty:" << isEmpty(&mylist) <<endl;
    for (int i = 0; i < size(&mylist); i++) {
        cout << getElement(&mylist,i) << " ";
    }
    cout<<endl;
    deleteElements(&mylist,5);
    updateElement(&mylist,1,1314);
    for (int i = 0; i < size(&mylist); i++) {
        cout << getElement(&mylist,i) << " ";
    }
    cout<<endl;
    int idx = findElement(&mylist,20);
    updateElement(&mylist,idx,520);
    for (int i = 0; i < size(&mylist); i++) {
        cout << getElement(&mylist,i) << " ";
    }
    cout<<endl;
    destroyList(&mylist);
    return 0;
}

c++自带顺序表

#include <iostream>
#include <vector> 
using namespace std;

int main() {
    vector<int> ret = {1,2,3,4,5};
    for (int i = 0; i < ret.size(); i++) {
        cout << ret[i] << " ";
    }
    cout<<endl;
    ret.push_back(1024);
    cout<<ret.size() <<endl;
    for (int i = 0; i < ret.size(); i++) {
        cout << ret[i] << " ";
    }
    cout<<endl;
}
这玩意谁研究的呢
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构--顺序栈
weixin_46203845的博客
12-02 88
#include <stdio.h> #include <stdlib.h> //预定义常量和类型 #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define STACK_INIT_SIZE 100 //存储空间分配量 #define STACKINCREMENT 10 //存储空间分配增量 typedef Status; typedef int SElemType; typedef struct{ SElemType
数据结构-顺序表基本操作的实现（含全部代码）
热门推荐
关注网络安全、云原生安全
09-13 21万+
今天起开始编写数据结构中的各种数据结构及其算法的实现。 主要依据严蔚敏版数据结构教材以及王道数据结构考研辅导书。 今天是线性表中的顺序表的实现，主要实现函数如下，读者有需要可以评论，我可以适当加几个。 CreatList(SqList &L,int n) 参数：顺序表L，顺序表长度n 功能：创建长度为的顺序表 时间复杂度：O(n) InitList(SqList &...
数据结构 --- c语言实现顺序表
weixin_60569662的博客
02-07 2225
线性表 零个或者多个数据元素组成的有限序列，除了头部和尾部元素之外的所有元素只有一个前驱元素 数据结构体中数组，单链表，双链表 ，循环链表等
数据结构-顺序表.zip
11-03
压缩包中共有两个文件，一个是顺序表的执行代码cpp文件，一个是顺序表的word文件，顺序表的word文件中写有代码所拥有的功能以及各功能的...不过数据结构就是要会C语言基础才开始学的，祝愿看了我资源的各位前程似锦呀！
JavaScript数据结构-2-顺序表
01-20
class SqList {  //2020/1/10  //python有可变参数，js没有。。。  //js也没有重载  //我又想到JAVA里有构造函数，我设想的js的构造函数应该跟java类似，在构造函数里初始化  //找了半天，没找到，还是慢慢找吧...
数据结构-顺序表-C语言实现顺序表相关功能-数据结构学习
05-22
C语言实现的数据结构中的顺序表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习 对顺序表边界操作的判定 实现了以下功能： 创建顺序表 向顺序表中插入元素(尾插法，...
数据结构-顺序表C++实现
03-30
在本实验中，我们将关注一种基础且重要的数据结构——顺序表，它在C++中得到了实现。顺序表是一种线性数据结构，其中元素按照它们被添加的顺序存储在连续的内存空间中。 首先，我们要理解顺序表的基本操作。顺序表...
数据结构-C语言描述（顺序表、链表）
04-01
水一下学校的实验报告，注释没有认真写，勿喷。
数据结构--二叉树和堆
binhyun的博客
07-07 833
1.基本概念 2.树的遍历方法 3.满二叉树&&完全二叉树 4.逻辑结构&&物理结构 5.推理公式 6.二叉树应用--堆 7.简单实现堆
数据结构第14节 加权图
hummhumm的专栏
07-07 1307
( V ) 是顶点的集合。( E ) 是边的集合，每条边连接 ( V ) 中的一对顶点。( W ) 是一个函数，将每条边映射到一个实数上，即 ( W: E \rightarrow \mathbb{R} )。
[数据结构] 基于插入的排序 插入排序&希尔排序
水墨不写bug
07-06 1145
插入排序&&希尔排序 实现原理
D1.排序
2302_79232710的博客
07-07 190
快速排序和归并排序
6、Redis系统-数据结构-03-压缩列表
qq_29434541的博客
07-07 1773
由于压缩列表需要进行空间扩展操作，这就需要重新分配内存，因此连锁更新一旦发生，会导致压缩列表占用的内存空间多次重新分配，直接影响到压缩列表的访问性能。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。而当新插入的元素较大时，可能会导致后续元素的。
【排序 - 堆排序】
最新发布
2302_80393814的博客
07-10 287
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
(三)前端javascript中的数据结构之链表上
峰会路转的博客
07-08 297
在js中，没有为我们提供原生的数据结构支持的，但是在java中是有提供的。所以需要我们去模拟这种结构实现。链表中最关键的一个元素，就是头节点，头节点不存储数据，指向第一个节点链表中几乎所有的操作都要从头结点开始。
数据结构--单链表实现
LH__1314的博客
07-05 1404
链表和顺序表都是线性表的一种，但是顺序表在物理结构和逻辑结构上都是连续的，但链表在逻辑结构上是连续的，而在物理结构上不一定连续；来看以下图片来认识链表与顺序表的差别这里以动态顺序表为例，和链表中的单链表对比一下动态顺序表单链表这里就可以很清晰的看到顺序表的底层其实就是一个数组，数据的是连续存储的（顺序表物理结构连续）；而链表它每一个数据都不是连续的（链表物理结构上不一定连续）。链表节点通过观察上图，我们会发现链表每一个节点都存放在数据和下一个节点的地址。
代码随想录第十二天|226.翻转二叉树、 101.对称二叉树、104.二叉树的最大深度、111.二叉树的最小深度
semirc9的博客
07-09 654
二叉树
算法与数据结构-030113451
08-03
本文档使用 看云 构建的内容主要围绕算法与数据结构展开，其中包括顺序表、单链表、循环链表、双向链表、栈的顺序存储和链式存储、队列的顺序存储和链式存储、顺序串、稀疏矩阵、广义表、二叉树以及链表的实战讲解。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值