顺序表的封装 (C++泛性编程（模板)）

最新推荐文章于 2022-04-09 13:16:47 发布
原创 最新推荐文章于 2022-04-09 13:16:47 发布 · 704 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C++ #顺序表 #模板

这篇博客展示了如何使用C++的泛型编程（模板）实现顺序表的封装，包括初始化、插入、删除、查找、排序等操作。示例代码详细解释了各个功能的实现方法，如push_back、push_front、show_list、sort等。

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

用C++ 实现顺序表的封装:             (使用模板）

               判表空， 判表满，获取 顺序表已占用长度， 显示表内信息；

               头插， 尾插，  头删， 尾删；

               特定位置插入数据， 特定数据处插入数据；          

               特定位置删除数据， 特定数据处删除数据；            

               查找特定位置数据， 查找特定数据所在位置；

               表内数据排序；

               去掉表内重复数据， 删除表内所有数据， 删除顺序表；

                清屏；

                

#ifndef _MYSEQLIST_H

#define _MYSEQLIST_H

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

template<typename Type>                                                  //定义模板类
class SeqList
{
public:
    SeqList(int sz = DEFAULT_SIZE);
    ~SeqList();

    bool is_empty()const;
    bool is_full()const;
    int  len_list()const;
    void show_list()const;

    bool push_back(const Type &x);
    bool push_front(const Type &x);
    bool pop_back();
    bool pop_front();

    bool insert_pos(int idex, Type &x);
    bool insert_value(Type &value, Type &x);
    bool delete_pos(int idex);
    bool delete_value(Type &value);
    Type &find_pos(int idex)const;
    int  find_value(Type &x)const;

    void sort();

    void resever();
    void clear();
    void remove_all();
    void destory();

private:
    enum{DEFAULT_SIZE = 8};
    int capacity;                               //初始申请顺序表长度
    int size;                                      //表内实际存放数据长度
    Type *base;                               //存放数据的数组
};


template<typename Type>
SeqList<Type>::SeqList(int sz)                                     //构造函数
{
    capacity = sz > DEFAULT_SIZE ? sz : DEFAULT_SIZE;
    base = new Type[capacity];
    size = 0;
}

template<typename Type>
SeqList<Type>::~SeqList()                                                     //析构函数
{
     delete []base;
     base = NULL;
     capacity = size = 0;
}

template<typename Type>                   
bool SeqList<Type>::is_empty()const                                     //判顺序表是否为空
{
     return size == 0;
}

template<typename Type>
bool SeqList<Type>::is_full()cons                                            //判顺序表是否已满                                              t
{
     return size >= capacity;
}
template<typename Type>
int SeqList<Type>::len_list()const                                           //获取表的长度
{
    return size;
}

template<typename Type>
void SeqList<Type>::show_list()const                                     //显示表内数据
{
    int i = 0;
    for (i = 0; i < size; ++i) {
        cout<<base[i]<<" ";
    }
    cout<<endl;
}

template<typename Type>
bool SeqList<Type>::push_back(const Type &x)                                          //尾插
{
    if (!is_full()) {
         base[size++] = x;
         return true;
    }
    return false;
}

template<typename Type>
bool SeqList<Type>::push_front(const Type &x)                                            //头插
{
    int i = 0;

    if (!is_full()) {
        for(i = size - 1; i >= 0; --i) {
            base[i + 1] = base[i];
        }
        base[0] = x;
        size++;
        return true;
    }

    return false;
}

template<typename Type>
bool SeqList<Type>::pop_back()                                                       //尾删
{
    if (!is_empty()) {
        size--;
        return true;
    }

    return false;
}

template<typename Type>
bool SeqList<Type>::pop_front()                                                        //头删
{
    int i = 0;

    if (!is_empty()) {
        for (i = 1; i< size; ++i) {
            base[i - 1] = base[i];
        }
        size--;
        return true;
    }

    return false;
}


template<typename Type>
bool SeqList<Type>::insert_pos(int idex, Type &x)                                     //特定位置插入数据
{
    int i = 0;

    if (is_full() || idex < 1 || idex > size + 1) {
        return false;
    }

    for (i = idex - 1; i < size; ++i) {
        base[i + 1] = base[i];
    }
    base[idex - 1] = x;
    size++;

    return true;
}

template <typename Type>
bool SeqList<Type>::insert_value(Type &value, Type &x)                               //特定数据处插入数据
{
    int idex = 0;
    int i = 0;

    if (is_full()) {
         return false;
    }

    for (i = 0; i < size; ++i) {
        if (base[i] =  value) {
            idex = i;
            break;
        }
    }

    for (i = idex; i < size; ++i) {
         base[i + 1] = base[i];
    }
    base[idex] = x;
    size++;

    return true;
}
template <typename Type>
bool SeqList<Type>::delete_pos(int idex)                                                          //特定位置删除数据
{
    int i = 0;

    if (is_empty() || idex < 1 || idex > size) {
        return false;
    }

    for (i = idex; i < size; ++i) {
        base[i - 1] = base[i];
    }
    size--;

    return true;
}

template <typename Type>
bool SeqList<Type>::delete_value(Type &value)                                             //特定数据处删除数据
{
    int idex = 0;
    int i = 0;

    if (is_empty()) {
         return false;
    }

    for (i = 0; i < size; ++i)
    {
        if (base[i] = value) {
            idex = i;
            break;
        }
    }

    for (i = idex; i < size - 1; ++i) {
        base[i] = base[i + 1];
    }
    size--;

    return true;
}

template <typename Type>
Type &SeqList<Type>::find_pos(int idex)const                                           //查找特定位置数据
{
    if (is_empty() || idex < 1 || idex > size) {
        cout<< "Can not find the value!"<<endl;
        return base[-1];
    }

    return base[idex - 1];
}

template <typename Type>
int SeqList<Type>::find_value(Type &x)const                                            //查找特定数据所在位置
{
     int i = 0;

     if(!is_empty()) {
         for (i = 0; i < size; ++i) {
             if (base[i] == x) {
                 return i + 1;
             }
         }
     }

    cout<< "Can not find the value!"<<endl;
    return -1;
}


template <typename Type>
void SeqList<Type>::sort()                                                                       //表内数据排序
{
    int i = 0;
    int j = 0;
    Type temp = 0;
    for (i = 1; i < size; ++i) {
        j = i - 1;
        temp = base[i];
        while (temp  < base[j]) {
            base[j + 1] = base[j];
            j--;
        }
        base[j + 1] = temp;
    }
}

template <typename Type>
void SeqList<Type>::resever()                                                         //去掉表内重复数据
{
    int i = 0;
    int j = 0;
    Type temp;

    for (i = 0; i < size - 1; ++i) {
        temp = base[i];
        for (j = i + 1; j < size; ++j) {
            if (base[j] == temp) {
                delete_pos(j + 1);
            }
        }
    }
}


template <typename Type>
void SeqList<Type>::clear()                                                                  //清屏
{
    system("clear");
}

template <typename Type>
void SeqList<Type>::remove_all()                                                         //删除表内所有数据
{
    while (size) {
         size--;
    }
}

template <typename Type>
void SeqList<Type>::destory()                                                               //删除整个顺序表
{
    remove_all();
    delete []base;

}


#endif



------------------------------------------------------------------------------------------------------------

                                                 //顺序表测试程序


#include <cstdlib>
#include "myseqlist.h"

int main(int argc, const char  *argv[])
{
    int sz = 0;
    int select = 0;
    int item = 0;
    int idex = 0;
    int value = 0;
    int value1 = 0;

    cout<<"请输入初始化所需顺序表的长度：";
    cin>>sz;
    SeqList<int> mylist(sz);

    while(1)
    {
        cout<<"*****************************************************"<<endl;
        cout<<"* [1] push_back(-1结束)    [2] push_fornt(-1结束)   *"<<endl;
        cout<<"* [3] show_list            [0] quit system          *"<<endl;
        cout<<"* [4] pop_back             [5] pop_fornt            *"<<endl;
        cout<<"* [6] insert_pos           [7] insert_value         *"<<endl;
        cout<<"* [8] delete_pos           [9] delete_value         *"<<endl;
        cout<<"* [10] find_pos            [11] find_value          *"<<endl;
        cout<<"* [12] sort                [13] resever              *"<<endl;
        cout<<"* [14] clear               [15] length              *"<<endl;
        cout<<"* [16] remove_all          [17] destroy             *"<<endl;
        cout<<"*****************************************************"<<endl;
        cout<<"请选择: ";
        cin>>select;

        switch(select)
        {
            case 0:
                cout<<"Bye Bye!"<<endl;
                exit(-1);

            case 1:
                cout<<"请输入要插入的数据(以-1结束): "<<endl;
                while(cin>>item, item != -1)
                {
                    mylist.push_back(item);
                }
                break;

             case 2:
                cout<<"请输入要插入的数据(以-1结束):"<<endl;
                while(cin>>item, item != -1)
                {
                    mylist.push_front(item);
                }
                 break;

             case 3:
                 mylist.show_list();
                 break;

             case 4:
                mylist.pop_back();
                break;

             case 5:
                mylist.pop_front();
                break;

             case 6:
                cout<<"请依次输入要插入的位置和数据："<<endl;
                cin>>idex>>value;
                mylist.insert_pos(idex, value);
                break;

             case 7:
                cout<<"请依次输入要插入位置的数据和要插入的数据："<<endl;
                cin>>value>>value1;
                mylist.insert_value(value, value1);
                break;

             case 8:
                cout<<"请输入要删除的位置："<<endl;
                cin>>idex;
                mylist.delete_pos(idex);
                break;

             case 9:
                cout<<"请输入要删除位置的数据："<<endl;
                cin>>value;
                mylist.delete_value(value);
                break;
             case 10:
                cout<<"请输入要查找的位置："<<endl;
                cin>>idex;
                cout<< mylist.find_pos(idex)<<endl;
                break;

             case 11:
                cout<<"请输入要查找的数据："<<endl;
                cin>>value;
                cout<< mylist.find_value(value)<<endl;
                break;

             case 12:
                mylist.sort();
                break;

             case 13:
                mylist.resever();
                break;

             case 14:
                mylist.clear();
                break;

             case 15:
                cout<<mylist.len_list()<<endl;
                break;

             case 16:
                mylist.remove_all();
                break;

             case 17:
                mylist.destory();
                break;

             default:
                cout<<"请重新输入："<<endl;
            }
    }

    return 0;
}


【数据结构】封装顺序表
Vcrossover的博客
12-15 1306
  最近在看《大话数据结构》，回顾一下之前数据结构的学习，之前是用C语言来完成的代码，鉴于已经学习了C++，此次便使用类来进行顺序表的封装吧！ 一、概念   顺序表，全名顺序存储结构，是线性表的一种，他符合线性表“一对一”的逻辑关系。同时又占用一组地址连续的存储单元。 动态顺序表：指的是用来存储数据的数组大小是我们动态申请的，用起来比较灵活。 静态顺序表：在设计的时候，就已经规定了数组的大小，不灵活。 此次我们使用的是动态顺序表来进行的操作。 二、设计顺序表 线性表的动态分配顺序存储结构 typedef
【C++】用vector容器封装顺序表（完整代码）
维欣~fighting✔
07-13 514
完整代码 #include<iostream> template<typename T> class Vector { public: Vector(int size = 2) { parr = new T[size]();//动态开辟空间 cursize = 0; totalsize = size; } ~Vector() { delete[] parr; parr = NULL; } //扩容 void resize() { T*
【C++】---封装顺序表
weixin_44915076的博客
07-22 376
封装顺序表：基础的数据结构有：顺序表、链表、栈、队列。这些数据结构我们都需要用到，但是在C语言中没有这样的库去供我们使用。但是C++中是有这样的库，也就是STL标准模板库中有一个组件是容器组件，容器组件中有一个顺序容器vector<int>就是来封装顺序表的，这样我们可以不用建立数据结构，可以直接使用这些数据结构。 由于数组是定长的，所以在封装顺序表的时候我们用到了扩容机制： 1、以倍数的形式开辟更大的空间 2、旧数据拷贝到新的空间中 3、旧空间释放 4、指针指向新空间 STL(标准模...
顺序表的封装
03-24 286
#include<iostream>typedef int DataType;typedef int Status;#define MaxSize 100typedef struct{ DataType data[MaxSize]; int length;}SeqList;#define TRUE 1#define FALSE 0#define OK 1#de...
【C++】封装顺序表
qq_43411563的博客
05-28 525
一、封装顺序表的引出 基础的数据结构有：顺序表、链表、栈、队列。 这些数据结构我们都需要用到 ，但是在C语言中没有这样的库去供我们使用。但是C++中是有这样的库，也就是STL标准模板库中有一个组件是容器组件，容器组件中有一个顺序容器中的vector<int>就是来封装顺序表的。 由于数组是定长的，所以在封装顺序表的时候我们用到了扩容机制： 1、以倍数的形式开辟更大的空间 2、旧数据拷贝到新的空间中 3、旧空间释放 4、指针指向新空间 二、代码实现封装顺序表 template<typenam
C/C++语言：顺序表 的封装
weixin_45580017的博客
04-09 1845
C/C++语言：顺序表的封装
C/C++顺序表实现及模板应用分析
根据给定的文件信息，我们可以推断出文件中包含的内容与顺序表的实现有关，涉及到C语言、C++语言以及模板编程。下面将详细介绍这些知识点。 ### 顺序表的定义和概念 顺序表是一种线性表的逻辑结构，它在内存中是...
C++实现顺序表的多文件编程与操作
顺序表的C++实现遵循面向对象编程的原则，将数据与操作封装在类中，提供给用户的接口是类的成员函数。这样的设计提高了代码的抽象性和重用性。为了实现顺序表，需要考虑以下设计要点： - **空间管理**：如何分配和...
C++实现顺序表初始化、长度查询、插入删除及遍历
最新发布
07-26
本文将详细介绍如何使用C++来实现顺序表，并阐述其基本操作，包括初始化、获取长度、插入元素、删除元素、遍历以及查找元素等。顺序表的特点是在内存中以连续的方式存储数据，这意味着所有元素在内存中的位置是连续...
数据结构课程设计图书信息管理系统报告(顺序表)（模板）
09-19
2. **实验与观测方法**：采用C++编程语言，利用顺序表数据结构实现系统核心功能。通过模拟读者借阅流程，测试系统的各项操作，验证其功能的正确性和性能。 3. **计算方法与编程原理**：在C++中，可以使用动态数组来...
数据结构顺序表C++模板(原创
03-11
总的来说，这个"数据结构顺序表C++模板"是学习和实践数据结构的宝贵资源，尤其是对于初学者，可以加深对顺序表的理解，提高编程技能，并为将来处理更复杂的数据结构和算法打下坚实基础。通过实际编写和调试代码，你...
顺序表C++模板类封装
WSTONECH的博客
07-14 486
顺序表+泛型+类的封装+实现cpp
顺序表的实现C++封装
J.Anson的博客
10-03 2251
数据结构内容中，用C++封装顺序表的实现
C++封装顺序表
qq_55904031的博客
09-22 397
文章目录前言一、顺序表是什么？二、需求分析三、具体实现 前言 前几期讲过类，构造函数，运算符重载，这一期就利用这三块的知识做一期简单的应用，用C++封装顺序表。 一、顺序表是什么？ 如图所示，在内存中的一块连续的空间 这种内存布局非常像数组，因此也被成为动态数组 在C++标椎模板库中有一个顺序表vector容器，我们要做的就是封装一个丐版的vector容器 二、需求分析 1.定义Myvector类，和内部接口 2.初始化、销毁、深拷贝 3.自动扩容 4.增删查改 5.获取大小和容量 6.用 [ 索引
C语言单链表实现初始化、创建、增、删、查等基本操作（详细）
热门推荐
Qian_Qian_IT的博客
09-25 7万+
C语言单链表实现初始化、创建、增、删、查等基本操作 #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef int ElemType; //定义单链表结构 typedef struct Node { ElemType data;//数据域 struct Node *next;//指针域 } LinkList; //初始化 LinkList *initList(LinkList *
用类的形式封装顺序表
xuruhua的博客
07-01 900
此前我已经实现了用C语言写一个顺序表，现在尝试使用c++；有需要的话可以浏览我之前的博客哦 静态顺序表：https://mp.youkuaiyun.com/postedit/79772162 动态顺序表：https://mp.youkuaiyun.com/postedit/79991561   typedef int DataType; class Vector { publi...
c++封装双向链表和顺序表
centor的博客
07-20 438
双向链表中每个节点结构如下代码实现#include <iostream> #include <assert.h> using namespace std;typedef int DataType; struct Node { Node(const DataType& data) : _pNext(NULL)//指向下一个节点 , _pPre(NULL)
C++封装顺序表和带头结点的双向循环链表
czf的编程工坊
04-19 391
啊
线性表（顺序表）之C++封装
小米的修行之路
07-15 1116
线性表概述 线性表是最基本、最简单、也是最常用的一种数据结构。在线性表中数据元素之间的关系是线性，数据元素可以看成是排列在一条线上或一个环上。 线性表分为静态线性表和动态线性表，常见的有顺序表(静态的)、单向链表(动态的)和双向链表(动态的)。 以下是对顺序表的封装： .h文件： #pragma once class CZzcList { public: CZz
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值