C++_Seqlist/Linklist

最新推荐文章于 2024-01-03 21:15:38 发布
最新推荐文章于 2024-01-03 21:15:38 发布
阅读量858 收藏 4
点赞数
分类专栏： C/C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shiyingkang___/article/details/75808276
版权

C++下实现顺序表，代码如下：

#include <iostream>
using namespace std;

//实现顺序表的下列接口： 
typedef int DataType; 
class SeqList 
{ 
public: 
    SeqList() 
        : _pData(new DataType[3]) 
        , _capacity(3) 
        , _size(0) 
    {} 

    SeqList(size_t n, DataType value)//构造一个容量为n，成员全是value的顺序表
        :_pData(new DataType[n])
        ,_capacity(n)
        ,_size(0)
    {
        for (;_size<n;++_size)
        {
            _pData[_size] = value;
        }
    }
    SeqList(const SeqList& s) 
    { 
        _pData = new DataType[s._capacity]; 
        _capacity = s._capacity; 

        // 方式一： 
        //memcpy(_pData, s._pData, s._size*sizeof(DataType)); 

        // 方式二： 
        _size = 0; 
        for(; _size < s._size; ++_size) 
            _pData[_size] = s._pData[_size]; 
    } 

    SeqList& operator=(const SeqList& s)
    {
        DataType* p = new DataType[s._capacity];
        for(size_t i=0; i < s._size; ++i) 
        {
            p[i] = s._pData[i];
        }
        delete _pData;
        _pData = p;
        _capacity = s._capacity;
        _size = s._size;

        return *this;
    }
    ~SeqList()
    {
        delete _pData;
        _size = 0;
        _capacity = 0;
    }
    void PushBack(const DataType& data)//顺序表尾部插入一个元素
    {
        _CheckCapacity();
        _pData[_size] = data;
        _size++;
    }
    void PopBack()//释放尾部最后一个元素
    {
        _size--;
    }
    void Insert(size_t pos, const DataType& data)//在下标为pos的位置插入一个元素data
    {
        _CheckCapacity();
        size_t i=_size;
        for (;i>=pos;i--)
        {
            _pData[i] = _pData[i-1];
        }
        _pData[i] = data;
        _size++;
    }
    void Erase(size_t pos)//删除下标为pos的元素
    {
        size_t i = pos-1;
        for (i;i<_size-1;i++)
        {
            _pData[i] = _pData[i+1];
        }
        _size--;
    }
    size_t Find(const DataType& data)//寻找元素data，并返回他的下标
    {
        for (size_t i = 0;i<_size;i++)
        {
            if (_pData[i] == data)
            {
                return i+1;
            }
        }
        return NULL;
    }
    size_t Size()const//返回顺序表的元素个数
    {
        return _size;
    }
    size_t Capacity()const//返回顺序表的容量
    {
        return _capacity;
    }
    bool Empty()const//判断顺序表是否为空
    {
        if (_size == 0)
        {
            return 1;
        }
        return 0;
    }
    void Clear()
    {
        _size = 0;
    }
    // 把顺序表中的有效元素改变到size个 
    void Resize(size_t size, const DataType& data)
    {
        if (size<_size)
        {
            _size = size;
        }
        else if (size > _size)
        {
            for (;_size < size;_size++)
            {
                PushBack(data);
            }
        }
    }
    DataType& operator[](size_t index)//下标运算符[]的重载
    {
        return _pData[index-1];
    }
    const DataType& operator[](size_t index)const
    {
        return _pData[index-1];
    }
    DataType& Front()//返回顺序表的第一个元素
    {
        return _pData[0];
    }
    const DataType& Front()const
    {
        return _pData[0];
    }
    DataType& Back()//返回元素表的最后一个元素
    {
        return _pData[_size-1];
    }
    const DataType& Back()const
    {
        return _pData[_size-1];
    }
    void DisPlay()
    {
        if (_size == 0)
        {
            cout<<"顺序表为空！！！"<<endl;
            return;
        }
        DataType* p = _pData;
        for (size_t i = 0;i<_size;i++)
        {
            cout<<p[i]<<"-->";
        }
        cout<<endl;
    }

private:
    void _CheckCapacity()//容量扩充
    { 
        if(_size == _capacity) 
        { 
            DataType* pTemp = new DataType[_capacity*2]; 
            for(size_t idx = 0; idx < _size; ++idx) 
                pTemp[idx] = _pData[idx]; 

            delete[] _pData; 
            _pData = pTemp; 
            _capacity *= 2; 
        } 
    } 

private: 
    DataType* _pData; 
    size_t _capacity; 
    size_t _size; 
};

测试代码：

void Test1()//测试构造，拷贝构造，赋值运算符重载
{
    cout<<"测试构造，拷贝构造，赋值运算符重载"<<endl;
    SeqList p1;
    p1.DisPlay();
    SeqList p2(5,2);
    p2.DisPlay();
    SeqList p3(p2);
    p3.DisPlay();
    p1 = p3;
    p1.DisPlay();
}

void Test2()//下标运算符[]重载，尾插，尾删，返回大小，返回容量，返回第一个元素，返回最后一个元素
{
    cout<<endl<<"下标运算符[]重载，尾插，尾删，返回大小，返回容量，返回第一个元素，返回最后一个元素"<<endl;
    SeqList p2;
    p2.PushBack(1);
    p2.PushBack(2);
    p2.PushBack(3);
    p2.PushBack(4);
    p2.DisPlay();
    cout<<"p2[3]="<<p2[3]<<endl;
    size_t tmp = p2.Size();
    cout<<"p2.Size()="<<tmp<<endl;
    tmp = p2.Capacity();
    cout<<"p2.Capacity()="<<tmp<<endl;
    DataType d = p2.Front();
    cout<<"p2.Front()="<<d<<endl;
    d = p2.Back();
    cout<<"p2.Back()="<<d<<endl;
}


int main()
{
    Test1();
    Test2();
    return 0;
}

测试结果：
这里写图片描述

C++实现链表，代码如下：

#include<iostream>
#include <assert.h>
using namespace std;


//链表 
#pragma once 
typedef int DataType; 


struct Node //结点的结构体
{ 
    Node(const DataType& data) 
        : _pNext(NULL) 
        , _pPre(NULL) 
        , _data(data) 
    {} 

    Node* _pNext; 
    Node* _pPre; 
    DataType _data; 
}; 

class List 
{ 
public: 
    List() 
        : _pHead(NULL)
        ,_tail(NULL)
    {} 
    List(size_t n, DataType data)//构造一个有n个结点，且结点的数据全是data的链表
    {
        _pHead = BuyNode(data);
        _tail = _pHead;
        while (--n)
        {
            Node* NewNode = BuyNode(data);
            _tail->_pNext = NewNode;
            NewNode->_pPre = _tail;
            _tail = _tail->_pNext;  
        }
    }
    void PushBack(const DataType& data)//链表尾部插入
    {
        Node* NewNode = BuyNode(data);
        if (_pHead == NULL)
        {
            _pHead = NewNode;
            _tail = _pHead;
        }
        else
        {
            _tail->_pNext = NewNode;
            NewNode->_pPre = _tail;
            _tail = NewNode;
        }
    }
    void PopBack()//释放链表最后一个元素
    {
        if (_pHead == NULL)
        {
            return ;
        }
        if (_pHead->_pNext == NULL)
        {
            _pHead = NULL;
            delete _tail;
            _tail = NULL;
            return ;
        }
        Node* cur = _tail;
        _tail = _tail->_pPre;
        _tail->_pNext = NULL;
        delete cur;
    }
    void PushFront(const DataType& data)//链表头部插入
    {
        Node* NewNode = BuyNode(data);
        if (_pHead == NULL)
        {
            _pHead = NewNode;
            _tail = _pHead;
        }
        else
        {
            _pHead->_pPre = NewNode;
            NewNode->_pNext = _pHead;
            _pHead = NewNode;
        }
    }
    void PopFront()//释放链表第一个结点
    {
        if (_pHead == NULL)
        {
            return ;
        }
        if (_pHead->_pNext == NULL)
        {
            _pHead = NULL;
            delete _tail;
            _tail = NULL;
            return ;
        }
        Node* cur = _pHead;
        _pHead = _pHead->_pNext;
        _pHead->_pPre = NULL;
        delete cur;
    }
    Node* Find(const DataType& data)//链表中寻找结点内元素为data的结点，并返回其地址
    {
        Node* cur = _pHead;
        while ((cur != NULL)&&(cur->_data != data))
        {
            cur = cur->_pNext;
        }
        return cur;
    }
    void Insert(Node* pos, const DataType& data)//指定位置插入一个结点
    {
        assert(pos != NULL);
        Node* NewNode = BuyNode(data);
        pos->_pPre->_pNext = NewNode;
        NewNode->_pPre = pos->_pPre;
        pos->_pPre = NewNode;
        NewNode->_pNext = pos;
    }
    void Erase(Node* pos)//删除指定位置的结点
    {
        assert(pos != NULL);
        pos->_pPre->_pNext = pos->_pNext;
        pos->_pNext->_pPre = pos->_pPre;
        delete pos;
    }
    size_t Size()//返回链表中有多少个结点
    {
        Node* cur = _pHead;
        size_t count = 0;
        while (cur != NULL)
        {
            count++;
            cur = cur->_pNext;
        }
        return count;
    }
    bool Empty()const//判断链表是否为空
    {
        if (_pHead == NULL)
        {
            return 1;
        }
        return 0;
    }
    List(const List& l)
        :_pHead(NULL)
        ,_tail(NULL)
    {
        Node* pl = l._pHead;
        while (pl != NULL)
        {
            PushBack(pl->_data);
            pl = pl->_pNext;
        }
    }
    List& operator=(const List& l)
    {
        Node* pl = l._pHead;
        if (pl == NULL)
        {
            if (_pHead == NULL)
            {
                return *this;
            }
            while (_pHead != NULL)
            {
                Node* cur = _pHead;
                _pHead = _pHead->_pNext;
                delete cur;
            }
            _tail = NULL;
            return *this;
        }
        else
        {
            if (_pHead == NULL)
            {
                while (pl != NULL)
                {
                    PushBack(pl->_data);
                    pl = pl->_pNext;
                }
                return *this;
            }
            Node* p = _pHead;
            while ((p != NULL)&&(pl != NULL))
            {
                p->_data = pl->_data;
                _tail = p;
                p = p->_pNext;
                pl = pl->_pNext;
            }
            if (p == NULL)
            {
                while (pl != NULL)
                {
                    PushBack(pl->_data);
                    pl = pl->_pNext;
                }
                return *this;
            }
            _tail->_pNext = NULL;
            while (p != NULL)
            {
                Node* cur = p;
                p = p->_pNext;
                delete cur;
            }
            return *this;
        }
    }
    ~List()
    {
        while (_pHead != NULL)
        {
            Node* cur = _pHead;
            _pHead = _pHead->_pNext;
            delete cur;
        }
        _tail = NULL;

    }

    void Display()
    {
        Node* p= _pHead;
        if (p == NULL)
        {
            cout<<"链表为空链表！！！"<<endl;
            return ;
        }
        while (p!= NULL)
        {
            cout<<p->_data<<"-->";
            p = p->_pNext;
        }
        cout<<"over"<<endl;
    }
private: 
    Node* BuyNode(const DataType& data)//获得一个结点 
    { 
        return new Node(data); 
    } 
private: 
    Node* _pHead; 
    Node* _tail;
};

测试代码：

void FunTest()//测试头插，尾插，头释放，尾释放，指定位置插入，指定位置删除，返回链表长度。
{
    List pLi(5,16);
    pLi.Display();
    pLi.PushBack(12);
    pLi.PushBack(7);
    pLi.PushBack(8);
    pLi.PushBack(4);
    pLi.Display();
    //pLi.PopBack();
    //pLi.Display();

    pLi.PushFront(2);
    pLi.Display();
    //pLi.PopFront();
    //pLi.Display();

    Node* pn = pLi.Find(12);
    if (pn)
    {
        cout<<"pLi.Find(12)"<<pn->_data<<endl;
    }

    pLi.Insert(pn,3);
    cout<<"Insert(pn,3)"<<endl;
    pLi.Display();
    pLi.Erase(pn);
    cout<<"Erase(pn)"<<endl;
    pLi.Display();


    size_t count = pLi.Size();
    cout<<"pLi.Size()"<<count<<endl;

    List pLi1(pLi);
    pLi1.Display();

}

void FunTest1()//赋值运算测试
{
    cout<<endl<<"赋值运算测试:"<<endl<<endl;
    List p1;
    cout<<"p1:"<<endl;
    p1.Display();
    List p2(5,6);
    cout<<"p2:"<<endl;
    p2.Display();
    List p3;
    cout<<"p3:"<<endl;
    p3.Display();
    List p4(2,3);
    cout<<"p4:"<<endl;
    p4.Display();
    List p5(7,8);
    cout<<"p5:"<<endl;
    p5.Display();
    List p6(4,4);
    cout<<"p6:"<<endl;
    p6.Display();

    p1 = p3;
    cout<<"p1 = p3"<<endl;
    p1.Display();

    p6 = p3;
    cout<<"p6 = p3"<<endl;
    p6.Display();

    p3 = p2;
    cout<<"p3 = p2"<<endl;
    p3.Display();

    p4 = p2;
    cout<<"p4 = p2"<<endl;
    p4.Display();

    p5 = p2;
    cout<<"p5 = p2"<<endl;
    p5.Display();


}


int main ()
{
    FunTest();
    FunTest1();
    return 0;
}

测试结果：
这里写图片描述
这里写图片描述

顺序表，链表中主要在拷贝构造函数，还有赋值运算符重载时，需要考虑到被赋值对象的大小问题，当被赋值对象大小大于赋值对象时，多余的部分需要手动释放掉，不够的部分可利用尾部插入函数，进行补充。

shiyingkang___
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++(14)：integer_sequence
风静如云的博客
11-21 893
注：由于是生成整数序列，所以T的类型；必须是整数类型：bool、char、char16_t、char32_t、wchar_t或是带符号或无符号整数类型。该程序利用模板推到求值了size_t N，然后用N生成队列一个整数序列，然后利用该整数徐磊作为索引值获取array的元素，生成tuple。
3-SeqList-Static.rar_4 3 2 1_C#_seqlist
09-20
数据结构，线性表，1. 插入一个学生 2. 删除一个学生 3. 修改学生信息 4 .输出所有学生信息 5. 保存数据并退出程序
数据结构_顺序表SeqList（C++
m0_61196791的博客
09-13 624
seqlist（C++实现
行星序列（seq）c++代码
最新发布
m0_66980218的博客
01-03 382
int n,p;int read()c=-1;return w*c;if (l==r)return;update(s);if (t==1)return;int mid;return;elseif (x>mid)else。
顺序表和链表（Sqlist&Linklist）
夜雨声烦烦不烦
10-13 5615
——————————————————————————————————————————— 众所周知，线性表是一个比较灵活的存储空间，其中有两种存储格式：线性表和链表，下文尽量详细地进行整理二者的特点和区别。 顺序表（Sqlist）： 顺序表，顾名思义，就是用连续的空间存储当下得到的数据。 顺序链性表用Sqlist称呼，提到Sqlist就指的是顺序链性表 其特点在于： 1.存储空间是连续的...
《数据结构》线性表-顺序表
qq_43246915的博客
09-15 276
线性表的顺序存储结构称为顺序表，其基本思想就是用一段地址连续的存储单元依次存储线性表的数据元素。 如何来实现 通常用一维数组来实现顺序表，也就是把线性表中相邻的元素储存在数组中相邻的位置，从而形成一一对应的关系。 需要注意的一点是：C++语言中数组下标是从0开始的，而线性表中元素的序号是从1开始的，也就是说线性表中的第i个元素存储在数组下标为i-1的位置上。 代码实现 #include...
seq_list.rar_seq_list_seqlist数据结构_seq线性表_顺序表的list类
09-24
数据结构，线性表的顺序存储方式,压缩包中提供了一个顺序表类和一些辅助函数，还有一个测试程序
seqlist.rar_Windows编程_Visual_C++_
08-12
教学所用的 用数组实现有序序列的存储
struct_vc.rar_VC 数据结构_struct VC_vc SeqList
09-19
用VC实现的几个常用的数据结构
类的继承第二次作业（多重继承与虚基类）参考答案_C++_teacher_
09-29
定义一个Person 类，结构如下图，为该类添加输入输出流运算符重载。Person 类以Public方式派生出一个Teacher类，数据成员包括：int gh(工号)；char* title(职称)，为该类添加输入输出流运算符重载，完成有参、无参、...
数据结构C++顺序表SeqList类
11-08
数据结构C++顺序表SeqList类的定义
seqlist 的代码C++编写
03-19
C++语言编写。 关于顺序表的代码，有插入删除查找匹配等函数。 仅供参考。
SeqStack.h
03-19
数据结构栈的头文件
C/C++编程：内存模型和数据竞争
OceanStar的博客
03-16 708
内存模型 内存模型为C++抽象机的目的定义了计算机内存存储的语义 可为C++程序所用的内存是一或者多个字节的连续序列。内存中的每个字节拥有唯一的肚子鼓 字节
数据结构与算法：一、线性表的顺序存储结构SeqList和链式存储结构LinkList
qq_42370809的博客
04-19 1018
实现了线性表的链式存储结构和线性存储结构，能进行插入元素O(n)，删除元素O(n)，查找元素O(n)和返回线性表长度O(1)的操作。其中链式存储结构使用了C++11的智能指针进行内存管理。 一、顺序存储结构SeqList 定义了数据类型ElemType，便于修改 使用状态stat，表示操作成功/失败 定义了线性表的长度length和用于存储数据的数组List[] 函数： 三个插入函数： stat insertElem(int index, ElemType *e);用下标插入 stat pus.
数据结构之C++实现顺序队列（SeqQueue）（无主函数）
manonghouyiming的博客
03-10 700
#include&lt;iostream&gt; using namespace std; #define SIZE 10 class SeqQueue { public: SeqQueue() { m_data = new int[SIZE]; m_head = m_rear = 0; } ~SeqQueue() { if(m_data != NULL) { de...
线性表——顺序数组seqList的实现 C++
净无邪博客
02-28 1696
本文主要总结常用的数据结构——线性表之数组实现，实现基本运算功能，不涉及完整功能，目的是为了熟悉常用数据结构特性和代码实现底层原理。 一、线性表——数组Array 1.1线性表定义 从逻辑上来看，线性表就是有n(n>=0)个数据元素a1，a2，…，an组成的有限序列。 对于一个非空的线性表，其逻辑结构特征如下： 有且仅有一个开始结点a1和一个直接后继节点a2，没有直接前驱节点，； 有且仅有一个终止节点an和一个直接前驱节点a*(n-1)*，没有直接后继节点； 其余的内部节点ai （2 <=
C++查找算法总结（可执行代码）
一叶知秋
09-10 4525
1. 顺序查找  核心：从数据的第一个元素开始，依次比较，直到找到目标数据或查找失败。 1.从表中的第一个元素开始，依次与关键字比较。 2.若某个元素匹配关键字，则 查找成功。 3.若查找到最后一个元素还未匹配关键字，则 查找失败。 时间复杂度：顺序查找平均关键字匹配次数为表长的一半，其时间复杂度为O(n)。 顺序查找的评估：顺序查找的优点是对表无要求，插入数据可在O(1)内完成。...
C++SeqList
无声的等候
03-18 1351
C++实现顺序表的若干功能 1.CheckCapacity 容量函数 2.PushBack/PushFront 插入数据和头插函数 3.PopBack/PopFront 删除数据和头删函数 4.Insert函数在指定的节点插入数据，Erase函数删除指定节点的数据 5.Print打印函数 6.测试函数 程序代码： #pragma once typedef int DataType
int *lp; typedef struct { int credit; // 学分 int usual_score;//平时成绩 int exp_score;//实验成绩 int paper_score;//卷面成绩 float final_score;//综合成绩 float real_credit;//实得学分 char course_id[3]; // 课程编号 char course_name[10]; // 课程名称 }grade; typedef struct { char student_id[2]; // 学号 char name[10]; // 姓名 char gender; // 性别 int dorm_num; // 宿舍号码 long phone_num; //电话号码 grade data[MAX]; }student; typedef struct { student data[MAX];//数据域 int length;//表长 }Seqlist;引用学号数组
05-29
Seqlist list; // 假设已经初始化了 list 数据域中的学生信息和学号数组 char student_id = list.data[0].student_id[0]; ``` 这里，list.data[0] 表示表中的第一个学生信息，.student_id[0] 表示该学生的学号数组...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值