【一篇文章搞懂顺序表代码】数据结构（C++）

已于 2024-07-19 16:35:44 修改
阅读量174 收藏
点赞数 3
分类专栏： 数据结构C++代码 文章标签： 数据结构 c++
于 2024-07-19 16:28:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54198185/article/details/140551538
版权

顺序表的定义以及基础操作

  1. 顺序表的定义：顺序表分为静态和动态两种类型。静态顺序表的长度是固定的，而动态顺序表的长度可以变化，以适应不同的存储需求。

  2. 顺序表的初始化：介绍了如何初始化静态和动态顺序表。静态顺序表的初始化较为简单，而动态顺序表需要动态分配内存。

  3. 顺序表的长度增加：对于动态顺序表，提供了一个方法来增加其长度，以适应更多的数据存储需求。

  4. 顺序表的插入操作：详细描述了如何在静态顺序表中插入新元素，包括对插入位置的合法性检查和元素的移动。

  5. 顺序表的删除操作：解释了如何从顺序表中删除指定位置的元素，并处理了元素的移动和内存释放。

  6. 顺序表的查找操作：介绍了两种查找方式：按位置查找和按值查找，展示了如何在顺序表中快速定位元素。

（1）顺序表的定义

        ①静态（长度不可变）

#define MAXSIZE 100 // 定义最大长度
typedef struct
{
    int data[MAXSIZE];
    int length;
} SqList;

        ②动态（长度可变）

#define InitSize 100
typedef struct
{
    int *data;
    int MaxSize;
    int length;
} SepList;

（2）顺序表的初始化

        ①静态

// 初始化一个顺序表(静态)
void InitSqList(SqList &L) {
    //不必要的默认值
    // for(int i=0;i<=L.length;i++){
    //     L.data[i]=0;
    // }
    L.length = 0;
}

        ②动态

// 初始化一个顺序表（动态）
void InitSepList(SepList &L) {
    L.data = (int *)malloc(InitSize * sizeof(int));
    if (L.data == NULL) {
        cout << "内存分配失败" << endl;
        exit(1);
    }
    L.length = 0;
    L.MaxSize = InitSize;
}

        动态可以增加表长：

// 写一个方法增加顺序表的长度
void IncreaseSize(SepList &L, int len) {
    int *p = L.data; // 创建一个p指针指向顺序表
    L.data = (int *)malloc((L.MaxSize + len) * sizeof(int));
    if (L.data == NULL) {
        cout << "内存分配失败" << endl;
        free(p);
        exit(1);
    }
    // 复制原来的数据到新的区域
    for (int i = 0; i < L.MaxSize; i++) {
        L.data[i] = p[i];
    }
    free(p);
    L.MaxSize += len;
}

（3）顺序表的插入

// 顺序表的插入（用的静态）
bool SqList_Insert(SqList &L, int i, int e) {
    // 把e插入到第i个位置上
    // 为了算法的健壮性，添加异常处理，判断i是否合法
    if (i < 1 || i > L.length + 1) {
        cout << "插入位置不合法，超出表的索引" << endl;
        return false;
    }
    if (L.length >= MAXSIZE) {
        cout << "表已经满啦~" << endl;
        return false;
    }
    for (int j = L.length; j >= i; j--) {
        // i之后的元素后移
        L.data[j] = L.data[j - 1];
    }
    L.data[i - 1] = e; // 把新的元素e插到的第i个位置
    L.length++;
    return true;
}

（4）顺序表的删除

// 顺序表的删除（用的静态）
bool SqList_Delete(SqList &L, int i, int &e) {
    if (i < 1 || i > L.length) {
        cout << "删除位置不合法，超出表的索引" << endl;
        return false;
    }
    e = L.data[i - 1]; // 获取被删除元素的值
    for (int j = i; j < L.length; j++) {
        // i之后的元素前移
        L.data[j - 1] = L.data[j];
    }
    cout << "删除了元素:" << e << endl;
    L.length--;
    return true;
}

（5）顺序表的查找

        ①按照位置查找

    //按位查找
bool SqList_GetByKey(SqList &L,int i, int &value){
    if (i < 1 || i > L.length) {
        cout << "查找位置不合法，超出表的索引" << endl;
        return false;
    }
    else{
        value=L.data[i-1];
        cout << "位置："<<i<<" 查找成功! 值为："<< value << endl;
        return true;
    }

}

        ②按照值查找

//按值查找
bool SqList_GetByvalue(SqList &L,int value,int &key){
    for(int i = 0; i<=L.length; i++){
        if(L.data[i]==value){
            key=i+1;
            cout<<"查找值："<<value<<" 成功，地址为："<<key<<endl;
            return true;
        }
    }
    cout<<"查找值："<<value<<" 失败。查无此值"<<endl;
    return false;
}

（6）全部完整代码（可以直接运行）

#include <iostream>
using namespace std;

#define MAXSIZE 100 // 定义最大长度
typedef struct
{
    int data[MAXSIZE];
    int length;
} SqList;

// 初始化一个顺序表(静态)
void InitSqList(SqList &L) {
    //不必要的默认值
    // for(int i=0;i<=L.length;i++){
    //     L.data[i]=0;
    // }
    L.length = 0;
}

#define InitSize 100
typedef struct
{
    int *data;
    int MaxSize;
    int length;
} SepList;

// 初始化一个顺序表（动态）
void InitSepList(SepList &L) {
    L.data = (int *)malloc(InitSize * sizeof(int));
    if (L.data == NULL) {
        cout << "内存分配失败" << endl;
        exit(1);
    }
    L.length = 0;
    L.MaxSize = InitSize;
}

// 写一个方法增加顺序表的长度
void IncreaseSize(SepList &L, int len) {
    int *p = L.data; // 创建一个p指针指向顺序表
    L.data = (int *)malloc((L.MaxSize + len) * sizeof(int));
    if (L.data == NULL) {
        cout << "内存分配失败" << endl;
        free(p);
        exit(1);
    }
    // 复制原来的数据到新的区域
    for (int i = 0; i < L.MaxSize; i++) {
        L.data[i] = p[i];
    }
    free(p);
    L.MaxSize += len;
}

// 顺序表的插入（用的静态）
bool SqList_Insert(SqList &L, int i, int e) {
    // 把e插入到第i个位置上
    // 为了算法的健壮性，添加异常处理，判断i是否合法
    if (i < 1 || i > L.length + 1) {
        cout << "插入位置不合法，超出表的索引" << endl;
        return false;
    }
    if (L.length >= MAXSIZE) {
        cout << "表已经满啦~" << endl;
        return false;
    }
    for (int j = L.length; j >= i; j--) {
        // i之后的元素后移
        L.data[j] = L.data[j - 1];
    }
    L.data[i - 1] = e; // 把新的元素e插到的第i个位置
    L.length++;
    return true;
}

// 顺序表的删除（用的静态）
bool SqList_Delete(SqList &L, int i, int &e) {
    if (i < 1 || i > L.length) {
        cout << "删除位置不合法，超出表的索引" << endl;
        return false;
    }
    e = L.data[i - 1]; // 获取被删除元素的值
    for (int j = i; j < L.length; j++) {
        // i之后的元素前移
        L.data[j - 1] = L.data[j];
    }
    cout << "删除了元素:" << e << endl;
    L.length--;
    return true;
}
//顺序表的查找：

    //按位查找
bool SqList_GetByKey(SqList &L,int i, int &value){
    if (i < 1 || i > L.length) {
        cout << "查找位置不合法，超出表的索引" << endl;
        return false;
    }
    else{
        value=L.data[i-1];
        cout << "位置："<<i<<" 查找成功! 值为："<< value << endl;
        return true;
    }

}
    //按值查找
bool SqList_GetByvalue(SqList &L,int value,int &key){
    for(int i = 0; i<=L.length; i++){
        if(L.data[i]==value){
            key=i+1;
            cout<<"查找值："<<value<<" 成功，地址为："<<key<<endl;
            return true;
        }
    }
    cout<<"查找值："<<value<<" 失败。查无此值"<<endl;
    return false;
}


int main() {
    SqList La;
    InitSqList(La);
    cout << "初始化后La的长度:" << La.length << endl;

    if (SqList_Insert(La, 1, 3)) { // 在第1个位置插入元素3
        cout << "太好了，插入成功了！" << endl;
    } else {
        cout << "可恶啊，插入失败了！" << endl;
    }

    cout << "插入一个元素后La的长度:" << La.length << endl;

    int e;
    if (SqList_Delete(La, 1, e)) { // 删除第1个位置的元素
        cout << "删除成功！" << endl;
    } else {
        cout << "删除失败！" << endl;
    }
    cout << "删除后La的长度:" << La.length << endl;
    SqList_Insert(La, 1, 3);//插入一个数据
    SqList_GetByKey(La,1,e);
    SqList_GetByvalue(La,4,e);
    return 0;
    
}

带风的小宋吃三碗
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法详解——链表篇（附c++实现代码）
JMasker的博客
05-01 3135
链表详解及完整实现
数据结构与算法-顺序表（链表篇）
09-09
本资源专注于"顺序表"中的"链表"部分，这是一组相关数据元素的集合，其内部组织方式不同于传统的数组。链表不依赖于内存中的连续空间，而是通过节点之间的引用连接来存储数据。 链表由一系列节点构成，每个节点包含...
数据结构-顺序表(c++)含全代码
Abieai的博客
11-24 6478
顺序表的原理及实现 文章目录前言一、顺序表是什么？二、创建顺序表三、顺序表的初始化及销毁1.顺序表的初始化2.顺序表的销毁四、顺序表的基本操作1.顺序表的添加元素2.顺序表的插入元素3.顺序表的删除元素4.打印顺序表的元素五、完整代码总结 前言 提示：以下是本篇文章正文内容，下面案例可供参考 一、顺序表是什么？ 线性表的顺序存储又称顺序表。 它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。 顺序表的特点是表中元素的逻辑顺序与其物理顺序相
C++数据结构：线性顺序表（链表）
攻城狮的博客
05-26 2499
前一篇文章介绍用数组实现的顺序表时已经提到链表这种结构，在STL中的 list 就是以链表实现的顺序表。这种结构与数组相比最大好处就是可以很方便的在头部和中部插入数据，而数组比较麻烦，需要移动之后的所有数据。链表也可以实现顺序表的功能。链表是一种动态数据结构，它可以根据需要自动调整大小，存储不连续的元素。
【数据结构篇C++实现】- 线性表 - 顺序表和链表
陈七的博客，学习知识分享，期待与大家的交流
03-20 2645
线性表知识总结，一文搞懂什么是顺序表与链表，以及常见的操作
数据结构：顺序表详解
Zhenyu_Coder的博客
07-30 5552
顺序表作为一种基本的数据结构，在许多应用场景中具有重要的意义和作用，可以提高数据的访问和操作效率，简化算法设计，提高内存利用率。本篇博客将向你详细介绍其模拟过程及全代码
【初阶数据结构】深入解析顺序表:探索底层逻辑
大一在读，博客主要分享C/C++方向相关的内容，欢迎关注我的博主，希望可以跟各位大佬深入学习！
06-11 3330
本篇将深入解析顺序表:探索底层逻辑，理解底层是如何实现并了解该接口实现的优缺点，以便于我们在编写程序灵活地使用该数据结构。
数据结构——顺序表（Ｃ语言版）
weixin_53811859的博客
03-30 6563
室友一把王者的时间，手把手带你拿捏严奶奶数据结构里面的动态顺序表实现（C语言版），纯手工绘画，保证让初学者的xdm也一目了然，精简易懂
C++数据结构：线性顺序表（数组）
攻城狮的博客
05-25 1339
将一个线性表存储到计算机中，把线性表的结点按逻辑顺序依次存放到一组地址连续的存储单元里，用这种方法存储的线性表称为顺序表。C++中数组、vector、list就是典型的顺序表，其中list是以链表实现的，本文主要以仿写一个数组实现的顺序表，进而更深入了解顺序表。
数据结构与算法上机实验一 顺序表
迈微AI研习社 · 号主
12-09 4791
本次继续更新数据结构与算法这门课的上机实验，主要涉及顺序表这一数据结构。
数据结构-双向链表(c++)超全超详细
热门推荐
Abieai的博客
12-01 1万+
文章目录前言一、双向链表是什么？二、双向链表上的基本操作1.定义双向链表2.初始化双链表3.前插法创建双链表4.尾插法创建双链表5.双向链表的遍历输出6.双链表的指定位置插入7.双链表的按位取值8.双链表的任意位置删除9.双链表的销毁三、全部代码(主函数部分比较凌乱）总结 前言 单链表结点中只有一个指向其后继的指针，使得单链表只能从头结点依次顺序地向后遍历。要访问某个结点的前驱结点（插入，删除操作时），只能从头开始遍历，访问后继结点的时间复杂度为O(1)，访问前驱结点的时间复杂度为O(n)。 提示：以.
顺序表的基本操作 一篇文章快速了解！
09-14
顺序表是一种常见的线性数据结构，它在计算机科学中扮演着重要的角色，特别是在数据结构和算法的学习中。本文将深入探讨顺序表的基本概念、操作及其应用。 顺序表是由一组相同类型的数据元素按照线性的顺序排列构成...
数据结构顺序表和4个链表的代码
09-13
本篇将深入探讨这两种数据结构及其在C++语言中的实现，通过分析提供的代码文件（dlink.cpp、sqlist.cpp、slink.cpp、cdlink.cpp、cslink.cpp），我们可以学习到不同类型的链表以及一个顺序表的实现方式。 首先，...
数据结构与算法（一）顺序表的实现
07-04
本篇文章将深入探讨顺序表的概念、特点以及如何实现其增删改查操作。 顺序表是一种线性数据结构，它的特点是所有元素存储在一块连续的内存区域中，通过数组来实现。数组的索引从0开始，每个元素都有一个唯一的索引...
数据结构与算法 c++实现 //删除顺序递增表中的重复元素 //对单链表实现就地逆置 //删除递增单链表中的重复元素
06-04
本篇文章将深入探讨在C++中实现数据结构，特别是顺序表和单链表的操作，以及如何处理它们的重复元素和逆序问题。 1. **顺序表**：顺序表是一种简单的数据结构，它的元素存储在一块连续的内存空间中，通过数组的形式...
数据结构--二叉树遍历
binhyun的博客
07-15 692
（1）前序遍历 （2）定义结构体 （3）前序遍历实现 （4）中序遍历实现 （5）二叉树的节点个数 （6）二叉树树叶节点个数 （7）二叉树的高度 （8）二叉树节点的开辟 （9）建立一个测试二叉树 （10）测试二叉树相关函数的功能 （11）第k层的数据个数 （12）二叉树里面查找节点
数据结构（初阶3.单链表）
2401_83968713的博客
07-14 656
一、单链表1.1概念与结构1.2结点1.3链表的性质1.4链表的打印二、实现单链表SList.hSList.c申请新节点尾插头插尾删头删在指定位置之前插入数据在指定位置之后插入数据删除指定位置结点删除指定位置之后的结点销毁结点test.c。
数据结构第35节 性能优化 算法的选择
最新发布
hummhumm的专栏
07-18 385
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 210
1%29%5D。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值