数据结构（list、vector、queue、stack C++实现）

最新推荐文章于 2024-07-28 08:47:13 发布
最新推荐文章于 2024-07-28 08:47:13 发布
阅读量803 收藏 1
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/konglongdanfo1/article/details/80924752
版权
本文介绍了作者在复习数据结构时，仿照STL实现的精简版C++数据结构，包括list、vector、queue和stack。强调模板类的类声明和实现应在同一文件，特别是头文件中，以便编译器实例化不同数据类型的类。文章提供了各个数据结构的实现代码及测试结果。
摘要由CSDN通过智能技术生成

最近在复习数据结构的内容，模仿了stl中的list、vector、queue和stack.当然是精简版的了，只写了最基本的功能。

这里要注意一点，模板类的类声明和定义要在同一个文件内，最好是在头文件内。因为模板类和模板函数在使用的时候才会被实例化，所以编译器需要知道所有的实现代码，然后去实例化各种数据类型的类或者函数。所以如果把类定义放在单独的源文件中的话，编译器找不到相关定义。

list

代码如下，这里实现的是双向循环链表

// list头文件
#pragma once
#include<exception>


template<typename T>
class list
{
public:
    list();
    virtual ~list();
    list(const list<T>& ob);
    list(list<T>&& ob);
    list<T> & operator= (const list<T> & ob);
    list<T> & operator= (list<T> && ob);
private:
    unsigned int m_nLength;
    node<T> * m_tailNode;
public:
    // 获取元素值
    T getElement(unsigned int index) const;
    // 获取头节点值
    T get_front() const;
    // 获取尾节点值
    T get_back() const;
    // 插入元素
    bool insert(unsigned int index, T elem);
    // 插入首位
    bool insert_front(T elem);
    // 在尾部插入
    bool insert_back(T elem);
    // 设置某个位置的值
    bool setValue(unsigned int index, T value);
    // 删除某个节点并返回该节点的值
    T deleteElement(unsigned int index);
    // 删除头节点，返回该节点的值
    T delete_front();
    // 删除尾节点并返回该节点的值
    T delete_back();
    // 删除所有节点
    void deleteAll();
    // 获取链表长度
    unsigned int getLength() const;
    // 链表是否为空
    bool empty() const;
};

template<typename T>
list<T>::list() : m_tailNode(nullptr), m_nLength(0u)
{
}

template<typename T>
list<T>::~list()
{
    deleteAll();
    m_tailNode = nullptr;
}

template<typename T>
list<T>::list(const list<T> & ob)
{
    try
    {
        unsigned int n = 0;
        while (n < ob.getLength())// 拷贝元素节点
        {
            insert_back(ob.getElement(n));
            n++;
        }
    }
    catch (std::exception e)
    {
        deleteAll();
        e.what();
    }
}


template<typename T>
list<T>::list(list<T> && ob)
{
    m_tailNode = ob.m_tailNode;
    m_nLength = ob.m_nLength;
    ob.m_tailNode = nullptr;
    ob.m_nLength = 0u;
}

template<typename T>
list<T> & list<T>::operator= (const list<T> & ob)
{
    if (!empty())
    {
        deleteAll();
        m_tailNode = nullptr;
    }
    try
    {
        unsigned int n = 0;
        unsigned int nLength = ob.getLength();
        while (n < nLength)
        {
            insert_back(ob.getElement(n));
            n++;
        }
    }
    catch (std::exception e)
    {
        deleteAll();
        e.what();
    }
    return * this;
}

template<typename T>
list<T> & list<T>::operator= (list<T> && ob)
{
    m_tailNode = ob.m_tailNode;
    m_nLength = ob.m_nLength;
    ob.m_tailNode = nullptr;
    ob.m_nLength = 0u;
    return * this;
}

template<typename T>
T list<T>::getElement(unsigned int index) const
{
    if (index >= m_nLength)
    {
        std::cout << "out of ranges" << std::endl;
        return 0;
    }
    T temp;
    if (index <= m_nLength / 2)
    {
        unsigned int n = 0;
        node<T> * pnode = m_tailNode;
        while (n++ <= index)
        {
            pnode = pnode->next;
        }
        temp = pnode->data;
    }
    else
    {
        unsigned int n = m_nLength - 1;
        node<T> * pnode = m_tailNode;
        while (n-- > index)
        {
            pnode = pnode->pre;
        }
        temp = pnode->data;
    }
    return temp;
}

template<typename T>
T list<T>::get_front() const
{
    return getElement(0u);
}

template<typename T>
T list<T>::get_back() const
{
    if (m_nLength == 0u)
    {
        return T;
    }
    return get_Element(m_nLength - 1);
}

template<typename T>
bool list<T>::insert(unsigned int index, T elem)
{
    if (index > m_nLength)
    {
        std::cout << "out of ranges" << std::endl;
        return false;
    }
    if (0u == m_nLength)
    {
        node<T> * pnode = new node<T>;
        if (nullptr == pnode)
        {
            throw (std::exception("内存分配出错!"));
        }
        m_tailNode = pnode;
        pnode->data = elem;
        pnode->next = m_tailNode;
        pnode->pre = m_tailNode;
    }
    else if (0u == index)// 插入第一位置
    {
        node<T> * pnode = new node<T>;
        pnode->data = elem;
        pnode->next = m_tailNode->next;
        m_tailNode->next = pnode;
        pnode->pre = m_tailNode;
        pnode->next->pre = pnode;
    }
    else if (m_nLength == index)// 插入尾部
    {
        node<T> * pnode = new node<T>;
        pnode->data = elem;
        pnode->next = m_tailNode->next;
        m_tailNode->next = pnode;
        pnode->pre = m_tailNode;
        pnode->next->pre = pnode;
        m_tailNode = pnode;
    }
    else if (index <= m_nLength / 2)
    {
        node<T> * pnode = m_tailNode;
        unsigned int n = 0u;
        while (n++ < index)// 定位到index上一个节点
        {
            pnode = pnode->next;
        }
        // 插入节点
        node<T> * pnodeElem = new node<T>;
        pnodeElem->data = elem;
        pnodeElem->next = pnode->next;
        pnode->next = pnodeElem;
        pnodeElem->pre = pnode;
        pnodeElem->next->pre = pnodeElem;
    }
    else
    {
        node<T> * pnode = m_tailNode;
        unsigned int n = m_nLength - 1;
        while (--n > index )// 定位到index上一个节点
        {
            pnode = pnode->pre;
        }
        node<T> * pnodeElem = new node<T>;
        pnodeElem->data = elem;
        pnodeElem->pre = pnode->pre;
        pnode->pre = pnodeElem;
        pnodeElem->next = pnode;
        pnodeElem->pre->next = pnodeElem;
    }
    // 长度增加
    m_nLength++;
    return true;
}

template<typename T>
bool list<T>::insert_front(T elem)
{
    return insert(0u, elem);
}

template<typename T>
bool list<T>::insert_back(T elem)
{
    return insert(m_nLength, elem);
}

template<typename T>
bool list<T>::setValue(unsigned int index, T value)
{
    if (index >= m_nLength)
    {
        std::cout << "out of ranges" << std::endl;
最低0.47元/天 解锁文章
konglongdanfo1
关注
专栏目录
c++ vector、stack、queue、map用法总结
yimixgg的博客
04-10 2437
c++ vector、stack、queue、map用法总结 一：vector容器用法总结 参考链接: https://blog.csdn.net/qq_36734094/article/details/79748612#commentBox 在c++中，vector是一个十分有用的容器。 作用：它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能...
数据结构实现（C++版）
11-28
内含资源如下： 1.基本数据结构 1.1.Array ........... 动态数组 1.2.LinkedList ... 链表 1.3.BST .............. 二分搜索树 1.4.MapBST ..... 二分搜索树（用于实现映射） 1.5.AVLTree ...... AVL树 2.接口 2.1.Queue ........... 队列接口 2.2.Stack .............. 栈接口 2.3.Set .................. 集合接口 2.4.Map ............... 映射接口 2.5.Merger .......... 自定义函数接口 2.6.UnionFind ..... 并查集接口 3.高级数据结构 3.1.ArrayQueue .......................... 队列_基于动态数组实现 3.2.LinkedListQueue .................. 队列__基于链表实现 3.3.LoopQueue ........................... 循环队列_基于动态数组实现 3.4.PriorityQueue ....................... 优先队列_基于最大二叉堆实现 3.5.ArrayPriorityQueue ............. 优先队列_基于动态数组实现 3.6.LinkedListPriorityQueue ..... 优先队列_基于链表实现 3.7.ArrayStack ............................. 栈_基于动态数组实现 3.8.LinkedListStack ..................... 栈_基于链表实现 3.9.BSTSet ..................................... 集合_基于二分搜索树实现 3.10.LinkedListSet ....................... 集合_基于链表实现 3.11.BSTMap ................................ 映射_基于二分搜索树实现 3.12.AVLTreeMap ....................... 映射_ 基于AVL树实现 3.13.LinkedListMap .................... 映射_基于链表实现 3.14.MaxHeap ............................. 最大二叉堆 3.15.SegmentTree ...................... 线段树 3.16.Trie ......................................... 字典树 3.17.QuickFind ............................ 并查集_基于数组实现 3.18.QuickUnion ......................... 并查集_基于树思想实现
数据结构所有代码C++实现
12-21
精心整理 一：线性表 1.单链表应用 例子一：尾插入创立单链表,并且删除相同元素,即表示一个集合 #include<iostream> using namespace std; struct node { int num; struct node *next; }; node *head; void creat_list() { int N,i; cin>>N; node*temp,*tail; head=new node; tail=head; tail->next=NULL; for(i=0;i<=N-1;i++) { temp=new node; if(temp==NULL) { cout<<"memory allocate fail and exit"; exit(1); } cin>>temp->num; tail->next=temp; tail=temp; tail->next=NULL; } } void out_put_list() { node* a=head->next; while(a!=NULL) { cout<<a->num<<" "; a=a->next; } cout<<endl; } void delete_list() { node *p,*q,*r; p=head->next; while(p) { q=p; while(q->next) { if((q->next)->num==p->num) { r=q->next; q->next=r->next; free(r); } else q=q->next; } p=p->next; } } int main(void) { creat_list(); out_put_list(); delete_list(); out_put_list(); return 0; }
数据结构——Queue队列(C++)
最新发布
ChloeWeever的博客
07-28 2576
队列（Queue）也是一种基本的数据结构，与栈类似，队列可以用来存储数据，并对数据进行插入删除操作，与栈不同的是，队列遵循的顺序是先进先出（你一定还记得栈是后进先出，我们用的刷盘子来举例），想象一列火车进隧道，车头先进的隧道，那么先出隧道的也是车头，这便是队列的原理。本文将使用C++对队列进行封装。
《数据结构——C++实现》（第二版）课本源代码
04-25
《数据结构——C++实现》（第二版）课本源代码，很全很给力
数据结构--简单二叉树--c++实现
weixin_43150428的博客
09-08 1016
** tree.h ** #ifndef tree_h #define tree_h class Tree { public: Tree(int size,int *root); ~Tree(); int *searchNode(int nodeIndex); bool addNode(int nodeIndex,int direction,int ...
C++数据结构代码实现.zip
10-10
在C++编程中，数据结构是至关重要的一个领域，它涉及...此外，这些代码还可以作为模板，帮助你在自己的项目中高效地实现数据结构功能。对于学习和提高C++编程能力，尤其是数据结构和算法方面，这是一个非常宝贵的资源。
基于C++实现数据结构列车车厢重排调度
03-27
在实现过程中，C++的STL（标准模板库）提供了丰富的数据结构和算法支持，如`std::vector`作为动态数组，`std::list`或`std::forward_list`作为链表，`std::queue`和`std::stack`作为线性容器，`std::priority_queue`...
数据结构-C++实现.zip
06-17
C++是一种强大的、通用的编程语言，它支持面向对象编程，使得实现数据结构更加直观和高效。在这个“数据结构-C++实现.zip”压缩包中，很可能是包含了一系列用C++语言实现的数据结构示例代码和相关学习资源。 数据...
C++版数据结构(全部结构的源码＋详细注释）
01-06
C++版数据结构,全部结构应有尽有，源码及详细注释
数据结构各种算法实现(C++)
05-04
数据结构各种算法实现(C++)，包含常见的所有数据结构，用C++模板实现
数据结构C/C++版源代码 严蔚敏
11-24
数据结构C/C++版源代码 严蔚敏，学数据结构的好东西。值得推荐大家。有人以前用邮箱向我索取过，我直接公布出来算了。
图数据结构的C++实现
07-10
图数据结构的C++实现，包括邻接表和邻接矩阵两种实现方式以及各种常用图算法，共同继承于抽象类。
数据结构c++-源代码
02-03
数据结构c++-源代码
【数据结构】C++实现（一）
weixin_43550839的博客
02-15 173
一.顺序表 用数组实现。尾插尾删较容易，头插头删需使用循环平移元素。 注意插入元素时判断容量，以及扩容方式。 #include<iostream> using namespace std; #define SIZE 10 template <class T> class seqlist1 { public: seqlist1() :capacity(SIZE) ...
数据结构 ——c++实现（知识点集合）
Ang_go的博客
03-18 1581
数据结构 ——c++实现（知识点集合） 某不知名学狗的复习记录，包含数据结构基本概念，线性表，栈、队列、递归，串、数组、广义表和树和森林内容整理。主要整理了知识点，代码较少。 第一章 绪论 1.1（算法+数据结构） = 程序 这个括号是体现面向对象的观点 1.2 数据结构的基本概念 数据结构的定义 数据，是信息的载体，是描述客观事物的数、字符、图形、图像、声音以及所有能输入计算机中并被计算机程序是别的和处理的符号的集合。 数据在特定的情况下可以是数字，或者是字符，数据对象就是数据的子集。例如一个特定的，
数据结构与算法（C++实现）
weixin_45216861的博客
03-06 6477
1.常见算法 1.最基础的算法-swap(交换) 1.1 swap语法： int main() { int a=1,b=10,temp; temp=a; a=b; b=temp; cout<<"a="<<a<<" b="<<b<<endl; system("pause"); return 0; } 1.2 值传递方式（不成功）： void swap1(int x,int y); int main() { int a,b;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值