顺序表--C++类的实现

于 2023-11-25 15:03:55 发布
阅读量472 收藏 13
点赞数 11
分类专栏： 数据结构 文章标签： 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74910357/article/details/134614885
版权

一.线性表的定义

线性表是一个若干个数据元素组成的有限序列

作为“序列”，除了第一个和最后一个元素，都是有前驱和后继的

二.顺序表的实现

顺序表是线性表的顺序存储方式，需要用到一段地址连续的存储单元来存储数据

顺序存储结构需要三个属性:

  • 存储空间的起始位置： 数组data

  • 线性表的最大存储空间：maxSize

  • 线性表的当前长度：last

我们重点来聊一聊数组长度和线性表长度的区别

  1. 数组长度maxSize是存放线性表存储空间的长度，一般是不变的，但是也可以改，但是会有损耗

  2. 线性表长度last是存放的数据元素的个数，这个是可以随意改变的

  3. last≤maxSize

那么顺序表类中的private部分的定义如下

template <class T>
class SeqList{
 private:
  T *data;
  int maxSize;
  int last;
  //这里也可以添加修改数组长度的函数，看个人需求
}

三.地址计算方法

Loc（第i个元素）=Loc（第一个元素）+（i-1）* c

c表示一个数据元素所占的存储空间

时间复杂程度为O（1）

通常把这种存储结构称为随机存储结构

四.顺序表的插入与删除操作

1.获取元素的操作
template <class T>
bool getData(int i,T&x){
   if(i>=0&&i<=last){    //判断i是否合法
     x=data[i];
     return true;
   }else{
     return false;
   }
}
2.插入操作

算法思路如下：

  • 如果线性表长度≥数组长度，抛出异常

  • 如果插入位置不合理，抛出异常

  • 从最后一个元素开始向前遍历到第i个位置，分别向后移动一个位置

  • 将要插入的元素添入位置中

  • 表长+1

那我们就来动手操作

template <class T>
bool Insert(int i,T&x){
  //第一步操作
    if(last>=maxSize-1){
     return false;
    }
  //第二步操作
    if(i<0||i>last){
     return false;
    }  
  //第三步操作
    for(int j=last;j>=i;j--){
     data[j+1]=data[j];          //后移操作

    }
  //第四步操作
    data[i]=x;
  //第五步操作
    last++;
  return true;
}

每一个数据结构我们需要熟练掌握其增删改减的方法，非常重要

3.删除操作

基本算法如下：

  • 删除的位置不合理，抛出异常(记得判断是否表空)

  • 取出删除元素

  • 从删除元素的位置开始遍历到最后一个元素，将它们向前移动一个位置

  • 表长减1

template <class T>
bool Delete(int i,T&x){
  //第一步
   if(last==0){
   return false;
   }
   if(i<0||i>last){
     return false;
   }
  //第二步
  x=data[i];
  //第三步
  for(int j=i;j<last;j++){
   data[j]=data[j+1];
  }
  //第四步
  last--;
  return true;
}

用之前学到的大O（）推导式我们可以得出

插入和删除的时间复杂程度是O（n）

详细内容见：数据结构中的基础算法-CSDN博客

五.顺序表的优缺点

优点：

  • 无需增加额外的存储空间

  • 可以快速存取任一位置的元素

缺点：

  • 插入和删除需要移动大量元素

  • 线性表长度变化大时，难以确定存储空间的容量

  • 造成存储空间的“碎片”

六.顺序表类的完整代码

本人一直用的代码，大家可以参考着写

#include <iostream>
using namespace std;
const int defaultSize = 100;
template<class T>
class SeqList {
protected:
    T* data;
    int maxSize;
    int last;//从零开始存的最后一个位置
    void reSize(int newSize);
public:
    SeqList(int sz = defaultSize);
    SeqList(SeqList<T>& L);
    ~SeqList() { delete[] data; }
    int Size()const { return maxSize; }
    int Length() { return last + 1; }
    int Search(T& x)const;  //const保护对象数据成员，且const成员函数执行时不能调用非const成员函数
    int Locate(int i)const;
    bool getData(int i, T& x)const
    {//输入的是第i位元素0，1，2，3...
        if (i >= 0 && i <= last) { x = data[i]; return true; }
        else return false;
    }
    void setData(int i, T& x)
    {//与上面同样 修改后：
        if (i >= 0 && i <= last)data[i] = x;
    }
    bool Insert(int i, T& x);
    bool Remove(int i, T& x);
    bool IsEmpty() { return (last == -1) ? true : false; }
    bool IsFull() { return (last == maxSize - 1) ? true : false; }
    void input();
    void output();
    SeqList<T>operator=(SeqList<T>& L);

};
template <class T>
SeqList<T>::SeqList(int sz) {
    if (sz > 0) {
        maxSize = sz;
        last = maxSize - 1;//修改01
        data = new T[maxSize];
        //if (data == NULL)
        //{
        //    cerr << "存储分配错误！" << endl; exit(1);
        //}
    }
}
template <class T>
SeqList<T>::SeqList(SeqList<T>& L) {
    maxSize = L.Size();
    last = L.Length() - 1;
    T value;
    data = new T[maxSize];
   // if (data == NULL)
   // {
    //    cerr << "存储分配错误！" << endl; exit(1);
    //}
    for (int i = 0; i <= last; i++) {
        L.getData(i, value);
        data[i] = value;
    }
}
template <class T>
void SeqList<T>::reSize(int newSize) {//未测试
    if (newSize <= 0)
    {
        cout << "无效的数组大小" << endl;
    }
    if (newSize != maxSize) {
        T* newarray = new T[newSize];
       // if (newarray == NULL)
       // {
        //    cerr << "存储分配错误！" << endl; exit(1);
       // }
        int n = last + 1;
        T* srcptr = data;
        T* destptr = newarray;
        while (n--)
            *destptr++ = *srcptr++;
        delete[] data;
        data = newarray;
        maxSize = newSize;
    }
}
template <class T>
int SeqList<T>::Search(T& x)const {
    for (int i = 0; i <= last; i++)//修改
        if (data[i] == x)
            return i;
    return 0;
}
template<class T>
int SeqList<T>::Locate(int i) const {
    if (i >= 0 && i <= last)//修改 ...这函数有什么用？
        return i;
    else
        return 0;
}
template <class T>
bool SeqList<T>::Insert(int i, T& x) {//第i位
    if (last == maxSize - 1)
        return false;
    if (i<0 || i>last)
        return false;
    for (int j = last; j >= i; j--)
        data[j + 1] = data[j];
    data[i] = x;
    last++;
    return true;
}
template <class T>
bool SeqList<T>::Remove(int i, T& x) {
    if (last == -1)
        return false;
    if (i<0 || i>last)return false;

    x = data[i];//存被删除的元素的值
    for (int j = i; j < last; j++)
        data[j] = data[j + 1];//修改03
    last--;
    return true;
}
template <class T>
void SeqList<T>::input() {
    // cout << "开始建立顺序表，请输入表中元素个数：";
    while (1) {
        cin >> last;
        last -= 1;//修改02
        if (last <= maxSize)
            break;
        //cout << "表中元素个数输入有误，范围不能超过" << maxSize - 1 << ":";
    }
    for (int i = 0; i <= last; i++) {
        //  cout << i << " ";
        cin >> data[i];
    }
}
template <class T>
void SeqList<T>::output() {
    //cout << "顺序表当前元素最后位置：" << last << endl;
   cout<<"{"<<" ";
    for (int i = 0; i <= last; i++)
        cout << data[i] << " ";
    cout <<"}"<< endl;
}
template <class T>
SeqList<T> SeqList<T>::operator = (SeqList<T>& L) {
    delete data;
    maxSize = L.Size();
    last = L.Length() - 1;
    T value;
    data = new T[maxSize];
    //if (data == NULL)
    //{
    //    cerr << "存储分配错误！" << endl; exit(1);
   // }
    for (int i = 0; i <= last; i++) {//修改04
        L.getData(i, value);
        data[i] = value;
    }
    return *this;
}
♬ 溪.
关注
  • 11
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《数据结构C++版》-顺序表实验-使用类模板的方式实现
10-24
用C++实现了数据结构中的顺序表，并且使用了面向对象知识中的类模板
C++顺序表的创建及常用14种操作
最新发布
程序猿老樊的博客
04-27 685
顺序表通常使用数组来实现。为了便于管理顺序表，我们通常定义一个结构体来封装数组和记录顺序表当前的长度。顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
顺序表（C++实现）
believeme464646的博客
05-30 1709
在f2函数中，我们可以使用lambda表达式或者std::bind将f1函数绑定到函数对象上，并将这个函数对象作为参数传递给for_each算法，从而实现在f2函数中调用f1函数。注意，在lambda表达式或者std::bind中，必须将当前对象的指针通过this传递进去，以确保能够调用类的成员函数。对于全局函数，因为它们不属于类的一部分，也没有成员变量可以被限制为只读，在全局函数中使用 const 关键字是无效的。
数据结构 · 线性表 | 顺序表
CGod的博客
11-09 1123
线性表是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储
C++实现顺序表、定义、初始化、增加长度操作
qq_42500148的博客
10-11 494
1.顺序表定义、初始化（静态分配） 运行结果： `@TOC 2.顺序表增加长度和再次初始化（动态分配） 运行结果： 说明：如果再增加长度后不再次进行顺序表值初始化，那数组的值就会自动识别为内存中原脏数据，例如：你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助
数据结构与算法基础篇1-线性表-顺序表的基本操作C++
2301_76210003的博客
04-23 526
线性表的顺序存储结构是指用一组地址连续的存储单元依次存储线性表的数据元素，使得线性表中在逻辑结构上相邻的数据元素存储在连续的物理单元中，即线性表中元素的逻辑次序与存储器中的物理次序一一对应，采用顺序存储结构的线性表通常简称为顺序表。本篇，我们介绍线性表的顺序存储结构 - 顺序表的一些基本操作的实现与其效果 展示！
数据结构-顺序表C++实现
03-30
数据结构是计算机科学中的核心概念...总的来说，顺序表是理解数据结构和算法的重要起点，通过C++实现顺序表，你将深入理解数组、内存管理和面向对象编程的概念。不断实践和优化，你将能更好地应对复杂的数据处理挑战。
C++实现动态顺序表
08-19
"C++实现动态顺序表" C++中实现动态顺序表是指使用C++语言来实现一个可以动态变化的顺序表结构。这种结构可以根据需要动态地分配和释放内存，从而提高程序的效率和灵活性。 在C++中，使用动态顺序表可以通过使用...
C++实现顺序表的方法
09-01
本篇文章将探讨如何使用C++实现一个顺序表类`SeqList`，并详细解释其中的关键代码和设计思路。 首先，`SeqList`类包含以下成员： 1. `_a`：指向存储元素的动态数组的指针。 2. `_size`：当前存储的元素数量。 3. `...
使用C++实现顺序链表
08-26
"使用C++实现顺序链表" 在计算机科学中，链表是一种常用的数据结构，它可以存储大量的数据。今天，我们将讨论如何使用C++语言实现顺序链表。 首先，我们需要创建一个头文件List.h，用于定义链表的结构和成员函数。...
用C++实现线性表的顺序存储
m0_70940447的博客
06-08 210
用C++实现线性表的顺序存储
C++实现线性表的顺序表
Johnor的博客
07-14 789
C++实现数据结构线性表的顺序表
c++数据结构顺序表实现
cangyue_a的博客
04-05 2097
c++数据结构中的方法通过面向对象的机制提高了程序的效率。
顺序表(C++实现)
热门推荐
qq_39559641的博客
04-07 1万+
一、实现要求 （1）求顺序表中第i个元素（函数），若不存在，报错。 （2）在第i个结点前插入值为x的结点。 （3）删除顺序表中第i个元素结点。 （4）在一个递增有序的顺序表L中插入一个值为x的元素，并保持其递增有序特性。 （5）将顺序表Ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），分别放入新的顺序表中，然后原表和新表元素同时输出到屏幕上，以便对照求解结果。 （6）求两个递增有序...
数据结构 | 顺序表的基本实现
m0_68732914的博客
07-24 502
最近刚在学习《数据结构与算法》，单纯地跟课、看书觉得并不能很好的掌握好这些知识点，所以决定尝试将学习的知识点归纳总结，也将其进行代码实现，强化对知识点的理解。即作为笔记、实践，又作为我的思路分享。因为初学，难免有不正确、不恰当之处，敬请指正！
数据结构之顺序表——C++具体实现
weixin_45338443的博客
03-25 325
顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。下面是顺序表c++实现~
C++的类实现顺序表
weixin_64272728的博客
07-19 482
c++是面向对象编程，其中c++的类 数据+函数。数据结构的实现与类的面向对象思想具有一致性。
C++的类实现之顺序表
weixin_43200943的博客
05-06 684
#include<iostream> using namespace std; typedef int Elem; //线性表是一种抽象数据类型；数组是一种具体的数据结构。 //线性表与数组的逻辑结构是不一样的. class SqList { public: SqList(int size); //构造函数 初始化内存容量为size的顺序表 ~SqList(); //析构函数 销毁内存 void CreatList(); //填充顺序表 void Disp.
顺序表的实现c++类模板
12-11
顺序表是一种数据结构，它可以存储一组有序的数据元素。在C++中，我们可以使用类模板来实现顺序表，使其可以存储不同类型的数据。 首先，我们需要声明一个类模板来表示顺序表，例如： ``` template <class T> class SeqList { private: T *data; // 用于存储数据的数组 int maxSize; // 顺序表的最大容量 int length; // 顺序表的当前长度 public: SeqList(int size); // 构造函数，初始化顺序表的最大容量 ~SeqList(); // 析构函数，释放动态分配的数组空间 void insert(int index, T element); // 在指定位置插入元素 void remove(int index); // 删除指定位置的元素 T get(int index); // 获取指定位置的元素 int find(T element); // 查找指定元素的位置 }; ``` 在类模板中，使用 `<class T>` 表示这是一个模板类，`T` 表示数据类型的占位符。通过类模板实现的顺序表，可以根据实际需要存储不同类型的数据，比如整数、浮点数、字符串等。 在类模板的成员函数中，我们可以使用模板类型 `T` 来定义函数参数和返回值的数据类型，从而使得这些函数可以适用于不同的数据类型。 总之，通过使用类模板，我们可以方便地实现一个通用的顺序表数据结构，使其可以存储不同类型的数据，并提供常用的操作方法，提高代码的复用性和灵活性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值