STL库中的list的使用和模拟实现

最新推荐文章于 2024-06-21 22:56:01 发布
最新推荐文章于 2024-06-21 22:56:01 发布
阅读量656 收藏
点赞数
分类专栏： c++ 模拟实现 文章标签： stl 链表 库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lvyibin890/article/details/78075807
版权

简单介绍list

上文我们讲到了STL库中的vector的使用和模拟实现，其实list和vector在很多地方都有相似之处。STL库中的list是一个双向循环链表。它的简单的结构如图
这里写图片描述

我们还是先来看看它里面有什么。

list的内容与使用

一.
这里写图片描述
首先还是雷打不动的三个成员函数，构造函数，析构函数和赋值运算符重载。

二.
这里写图片描述
其次是迭代器。这里需要注意一下的是，begin（）返回的是第一个元素的位置，也就是头节点head的下一个位置；end（）返回的是最后一个元素的下一个位置，也就是头节点head的位置。在这里我们讲一下迭代器失效的问题。

int main()
{
    int a[] = { 1,2,3,4 };
    list<int> mylist(a,a+4);
    list<int>::iterator it = mylist.begin();
    while (it != mylist.end())
    {
        if (*it % 2 == 0)
        {
            mylist.erase(it);
        }
        else
        {
            ++it；   
        }
    }
    return 0；
}

上面的代码程序会崩溃，因为在STL里，我们不能以指针来看待迭代器，指针是与内存绑定的，而迭代器是与容器里的元素绑定的，删除了之后，该迭代器就失效了，在对其重新赋值之前，不能再访问此迭代器。

int main()
{
    int a[] = { 1,2,3,4 };
    list<int> mylist(a,a+4);
    list<int>::iterator it = mylist.begin();
    while (it != mylist.end())
    {
        if (*it % 2 == 0)
        {
            it= mylist.erase(it);
        }
        else
        {
            ++it;
        }
    }
}

这样就不会崩溃了，用it重新接收一下erase的返回值，因为erase的返回值是删除节点的下一个节点。
rbegin（）与rend（）是逆序访问链表的意思，和vector的用法差不多。

三.
这里写图片描述
上面的用法与vector的也差不多，就不一一介绍了。

四.
这里写图片描述
front（）：返回第一个节点的数据；
back（）：返回最后一个节点的数据；

五.
这里写图片描述
这些操作中，只比vector多了两个操作函数。
push_front（）：头插。
pop_front（）：头删。
这两个函数非常的简单，就不举例一一测试了。
insert函数有两种参数的用法；

int main()
{
    int a[] = { 1,2,3,4 };
    list<int> mylist(a,a+4);
    mylist.insert(mylist.begin(), 0);//在首元素的前面插入一个0
    mylist.insert(mylist.end(), 3, 5);//在尾元素的后面插入三个5
    list<int>::iterator it;
    for (it = mylist.begin(); it != mylist.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;
    system("pause");
    return 0;
}

这里写图片描述

六.

这里写图片描述
这是list中容器适配器的内容，我们来仔细看一下。

splice（）：往一个list1的某一个位置插入list2的内容。

int main()
{
    list<int> mylist1, mylist2;
    for (size_t i = 1; i <= 3; ++i)
    {
        mylist1.push_back(i);  //mylist1: 1 2 3
        mylist2.push_back(i * 10);// mylist2: 10 20 30
    }
    list<int>::iterator it;
    it = mylist1.begin();
    ++it;//"it" points 2 now
    mylist1.splice(it, mylist2);//mylist1: 1 10 20 30 2 3
                                //mylist2(empty)
                                //"it" still points to 2
    mylist2.splice(mylist2.begin(), mylist1, it);//mylist1: 1 10 20 30 3
                                                 //mylist2: 2
                                                 //"it" now is invalid
    it = mylist1.begin();
    advance(it, 3);//"it" points to 30
    mylist1.splice(mylist1.begin(), mylist1, it, mylist1.end());
                                                 //mylist1: 30 3 1 10 20
    for (it = mylist1.begin(); it != mylist1.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;
    for (it = mylist2.begin(); it != mylist2.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;
    system("pause");
    return 0;
}

remove（）：找出value然后删除；

int main()
{
    int a[] = { 1, 2, 3, 4 };
    list<int> mylist(a,a+4);
    list<int>::iterator it;
    mylist.remove(1);
    for (it = mylist.begin(); it != mylist.end(); ++it)
    {
        cout << *it << " ";
    }   
    cout << endl;
    system("pause");
    return 0;
}

这里写图片描述

remove_if（）：条件删除，把不符合条件的删除；

bool check(const int& value)//判断是否小于4
{
    return(value < 4);
}

int main()
{
    int a[] = { 1, 2, 3, 4 };
    list<int> mylist(a,a+4);
    list<int>::iterator it;
    mylist.remove_if(check);
    for (it = mylist.begin(); it != mylist.end(); ++it)
    {
        cout << *it << " ";
    }   
    cout << endl;
    system("pause");
    return 0;
}

这里写图片描述

unique（）：去掉重复的数值（需要注意的是，unique是有序的条件下去重，使用之前最好先排序）

int main()
{
    int a[] = { 1, 2, 4, 4 };
    list<int> mylist(a,a+4);
    list<int>::iterator it;
    mylist.unique();
    for (it = mylist.begin(); it != mylist.end(); ++it)
    {
        cout << *it << " ";
    }   
    cout << endl;
    system("pause");
    return 0;
}

这里写图片描述

sort（）：排序

int main()
{
    int a[] = { 1, 4 ,2, 3 };
    list<int> mylist(a,a+4);
    list<int>::iterator it;
    mylist.sort();
    for (it = mylist.begin(); it != mylist.end(); ++it)
    {
        cout << *it << " ";
    }   
    cout << endl;
    system("pause");
    return 0;
}

这里写图片描述

reverse（）：逆序

int main()
{
    int a[] = { 1, 4 ,2, 3 };
    list<int> mylist(a,a+4);
    list<int>::iterator it;
    mylist.reverse();
    for (it = mylist.begin(); it != mylist.end(); ++it)
    {
        cout << *it << " ";
    }   
    cout << endl;
    system("pause");
    return 0;
}

这里写图片描述

merge（）：合并有序的链表。

int main()
{
    int a[] = { 1, 2 ,3, 4 };
    int b[] = { 5, 6, 7, 8 ,9};
    list<int> mylist1(a,a+4);
    list<int> mylist2(b, b + 5);
    list<int>::iterator it;
    mylist1.merge(mylist2);
    for (it = mylist1.begin(); it != mylist1.end(); ++it)
    {
        cout << *it << " ";
    }   
    cout << endl;
    system("pause");
    return 0;
}

这里写图片描述

模拟实现list

#pramga once
#include <iostream>
using namespace std;

#include <assert.h>


//链表节点的结构
template <class T>
struct ListNode
{
    T _data;
    ListNode<T>* _prev;
    ListNode<T>* _next;

    ListNode(const T& data)//给一个const T类型的引用
        :_data(data)
        , _prev(NULL)
        , _next(NULL)
    {}
};


//链表的迭代器
template <class T,class Ptr,class Ref>
struct ListIterator
{
    typedef ListNode<T> Node;
    typedef ListIterator<T, T*, T&> Iterator;
    typedef ListIterator<T,Ptr,Ref> Self;

    Node* _node;

    ListIterator(Node* node)//给一个链表节点的指针
        :_node(node)
    {}

    ListIterator()
    {}

    ListIterator(const Self& it)
    {
        _node = it._node;
    }

    Ref operator*()
    {
        return _node->_data;
    }

    Ptr& operator->()
    {
        return &(_node->_data);
    }

    Self& operator++()//前置++
    {
        _node = _node->_next;
        return *this;
    }

    Self operator++(int)//后置++
    {
        Self tmp(*this);
        _node = _node->_next;
        return tmp;
    }

    Self& operator--()//前置--
    {
        _node = _node->_prev;
        return *this;
    }

    Self operator--(int)//后置--
    {
        Self tmp(*this);
        _node = _node->_prev;
        return tmp;
    }

    bool operator==(const Self& it)
    {
        return _node == it._node;
    }

    bool operator!=(const Self& it)
    {
        return _node != it._node;
    }
};

//双向循环链表
template <class T>
class MyList
{
    typedef ListNode<T> Node;
public:
    typedef ListIterator<T, T*, T&> Iterator;
    MyList()
    {
        _head = BuyNode(T());
        _head->_next = _head;
        _head->_prev = _head;
    }

    ~MyList()
    {
        Clear();
        delete _head;
        _head = NULL;
    }

    //访问相关接口
    Iterator Begin() 
    {
        return _head->_next;
    }

    Iterator End() 
    {
        return _head;
    }

    T& Front()
    {
        return _head->_next->_data;
    }

    T& Back()
    {
        return _head->_prev->_data;
    }

    bool Empty()
    {
        return _head->_next == _head&&_head->_prev == _head;    
    }

    size_t Size()
    {
        size_t count = 0;
        Node* cur = _head->_next;
        while (cur != _head)
        {
            count++;
            cur = cur->_next;
        }
        return count;
    }

    //插入相关接口
    void PushBack(const T& x)
    {
        /*Node* newNode = BuyNode(x);
        Node* tail = _head->_prev;
        newNode->_next = _head;
        tail->_next = newNode;
        newNode->_prev = _head;
        _head->_prev = newNode;*/
        Insert(End(), x);
    }

    void PushFront(const T& x)
    {
        /*Node* newNode = BuyNode(x);
        Node* next = _head->_next;
        newNode->_next = next;
        next->_prev = newNode;
        newNode->_prev = _head;
        _head->_next = newNode;*/
        Insert(Begin(), x);
    }

    Iterator Insert(Iterator pos, const T& x)
        //在pos前面插入一个元素，返回新加入元素的迭代器
    {
        Node* newNode = BuyNode(x);
        Node* cur = pos._node;
        newNode->_next = cur;
        cur->_prev->_next = newNode;
        newNode->_prev = cur->_prev;
        cur->_prev = newNode;
        return Iterator(newNode);   
    }

    void Insert(Iterator pos, size_t n, const T& x)
        //在pos位置之前插入n个x元素，与上一个Insert形成重载
    {
        for (size_t i = 0; i < n; ++i)
        {
            Insert(pos, x);
        }
    }

    void Insert(Iterator pos, Iterator b, Iterator e)
        //在pos的位置插入[b,e)的内容
    {
        Iterator tmp = b;
        for (tmp = b; tmp != e; tmp++)
        {
            Insert(pos, tmp._node->_data);
        }
    }

    //删除相关接口
    Iterator Erase(Iterator pos)
    {
        assert(pos != End());
        Node* cur = pos._node;
        Node* del = cur;
        cur = cur->_next;
        del->_prev->_next = del->_next;
        del->_next->_prev = del->_prev;
        delete del;
        del = NULL;
        return Iterator(cur);
    }

    void PopBack()
    {
        Erase(--End());
    }

    void PopFront()
    {
        Erase(Begin());
    }
    //打印相关接口
    void Print()
    {
        Node* cur = _head->_next;
        while (cur != _head)
        {
            cout << cur->_data << " ";
            cur = cur->_next;
        }
    }
protected:
    Node* BuyNode(const T& x)
    {
        Node* newNode = new Node(x);
        return newNode;
    }

    void Clear()
    {
        Node* cur = _head->_next;
        while (cur != _head)
        {
            Node* tmp= cur->_next;
            delete cur;
            cur = tmp;
        }
        _head->_next = _head;
        _head->_prev = _head;
    }
protected:
    Node* _head;
};

相关测试代码如下

void TestMyList1()//测试PushBack
{
    int a[] = { 1, 2, 3, 4 };
    MyList<int> list;
    for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        list.PushBack(a[i]);
    }
    list.Print();
    cout << endl;
}

这里写图片描述

void TestMyList2()//测试PushFront
{
    int a[] = { 1, 2, 3, 4 };
    MyList<int> list;
    for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        list.PushBack(a[i]);
    }
    list.PushFront(0);
    list.Print();
    cout << endl;
}

这里写图片描述

void TestMyList3()//测试Insert
{
    int a1[] = { 1, 2, 3, 4 };
    MyList<int> list1;
    for (size_t i = 0; i < sizeof(a1) / sizeof(a1[0]); ++i)
    {
        list1.PushBack(a1[i]);
    }
    MyList<int>::Iterator it=list1.Begin();
    //测试第一个insert
    it=list1.Insert(it, 0);
    list1.Print();
    cout << endl;

    //测试第二个insert
    it = list1.End();
    list1.Insert(it, 3, 5);
    list1.Print();
    cout << endl;

    //测试第三个insert
    it--;
    int a2[] = { 1, 2, 3, 4 };
    MyList<int> list2;
    for (size_t i = 0; i < sizeof(a2) / sizeof(a2[0]); ++i)
    {
        list2.PushBack(a2[i]);
    }
    list1.Insert(it, list2.Begin(), list2.End());
    list1.Print();
    cout << endl;
}

这里写图片描述

void TestMyList4()//测试PopBack、PopFront、Erase
{
    int a[] = { 1, 2, 3, 4 };
    MyList<int> list;
    for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        list.PushBack(a[i]);
    }
    list.PopBack();//删除4，剩1 2 3
    list.PopFront();//删除1，剩2 3
    list.Erase(list.Begin());//删除2
    list.Print();
    cout << endl;
}

这里写图片描述

void TestMyList5()//测试其他接口
{
    int a[] = { 1, 2, 3, 4 };
    MyList<int> list;
    for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        list.PushBack(a[i]);
    }
    int size = list.Size();
    cout << size;
    cout << endl;
    int num1 = list.Front();
    cout << num1;
    cout << endl;
    int num2 = list.Back();
    cout << num2;
    cout << endl;
    list.PopBack();
    list.PopBack();
    list.PopBack();
    cout << list.Empty();
    cout << endl;
}

这里写图片描述

TLpigff
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL中list的使用及其模拟实现
weixin_45897952的博客
04-28 857
目录 1.STL中的list的底层结构 2.list的使用 2.1构造对象： 2.2链表的遍历方式： 2.3链表的操作（在链表中是没有扩容操作的，因为是链表数据结构，所以直接插入元素就可以了） 1.resize() 2.clear()清空链表 3.front()&&back()（获取首/尾元素可以直接对其进行更改） 4.插入和删除元素 3.list的模拟实现： 1.STL中的list的底层结构 STL...
STL中list模拟实现源码
08-06
list模拟实现源码，适合初学者学习
C++标准模板库STL——list的使用及其模拟实现
希望自己从编程小白变成大佬
09-25 1107
list的文档介绍1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
C++标准库：STL以及输入输出库，IO库，Cmath库，时间库，智能指针库与并发库等简介
最新发布
追赶时代的博客
06-21 1472
c++标准库 STL cmath chrono iostream thread mutex condition_variablecondition_variable
C++ STL之list的使用及模拟实现
czh1592272237的博客
01-23 1874
本篇文章详细讲解了STL中list的使用及模拟实现，以及反向迭代器类模板的实现。
C++ STL学习之【list的模拟实现】
北 海的博客
04-13 4321
STL中的list是一个双向带头循环链表，作为链表的终极形态，各项操作性能都很优秀，尤其是list中迭代器的设计更是让人拍案叫绝，如此优秀的容器究竟是如何实现的？本文将带你共同揭晓
C++STL之list的使用和模拟实现
小赵小赵福星高照的博客
11-30 1719
list 文章目录listlist成员函数的使用list的构造函数list的遍历方式assignpush_back和push_frontpop_back和pop_frontinserteraseclearswapsortuniqueremove容器的迭代器的分类容器算法迭代器之间的关系list的模拟实现list迭代器的实现list迭代器和const迭代器模拟实现vector迭代器和list迭代器比较push_back模拟实现push_front模拟实现insert模拟实现erase模拟实现pop_back模
【C++】STL：list的使用及模拟实现
weixin_51983604的博客
09-25 971
文章目录一、list的介绍二、list的使用1.构造函数2.遍历3.数据的插入与删除（1）尾部的插入与删除（2）头部的插入与删除（3）任意位置插入与删除三、总结 一、list的介绍 list是可以在常数范围内在任意位置进行效率为O(1)的插入和删除的序列式容器，并且该容器可以前后双向迭代。 list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素，关于双向链表的细节可以移步数据结构（二）：链表。 二、list的使用 1.构造函数 常用的构.
07 STL中list的用法和模拟实现
精致的灰的博客
11-10 967
文章目录一、list介绍二、常用接口2.1. 构造函数默认构造半缺省构造拷贝构造迭代器构造2.2. 增删查改的接口push_front和pop_frontpush_back和pop_backfindinserterase2.3. 迭代器begin和endrbegin和rend2.4. 元素访问方式front和back迭代器和范围for访问2.5. 大小控制函数sizeresizeemptyclear2.6. list的其他操作函数sortswapspliceremoveremove_ifuniquemerg
C++ STL之stack的使用及模拟实现
czh1592272237的博客
01-23 638
本篇文章详细讲述了STL中stack的使用及模拟实现。
【STL】list剖析及模拟实现
阿润菜菜的博客
03-11 3038
STL---list的剖析及模拟实现
c模拟c++ stl list
06-18
通过这样的实现，我们可以获得一个功能接近C++`std::list`的C语言版本，虽然在灵活性和效率上可能有所妥协，但它提供了一种在纯C环境中使用类似链表容器的方式。对于那些需要在C环境中实现高效数据结构和算法的...
stl模板库的c语言实现
05-17
总的来说，这个项目为那些希望深入了解C++ STL工作原理，或者需要在不支持C++的环境中使用类似功能的程序员提供了一个宝贵的学习和实践资源。通过研究和使用libcstl，可以更好地理解数据结构、算法以及C语言和C++...
C++开源项目：模拟实现小型STL
11-27
本开源项目旨在模拟实现一个小型STL，帮助开发者更深入地理解STL的工作原理和设计思想。下面我们将详细探讨其中涉及的知识点。 1. **容器**：STL中的容器是用来存储数据的对象，如`vector`、`deque`、`list`、`set`...
双向链表List模板类（模拟STL容器中的list）
02-07
双向链表List模板类（模拟STL容器中的list），提供插入删除，清空，获取链表长度，判断链表是否为空等操作，内置了迭代器类型
Ubuntu16.04安装boost库
热门推荐
pigff的博客
07-02 3万+
到boost官网安装一个boost库的压缩包，我下的是1.67.0版本执行下面的命令解压tar -xzvf boost_1_67_0.tar.gz 解压出来以后，进入解压出来的文件夹，执行下面的命令sudo ./bootstrap.sh在执行下面的命令，这样头文件就被默认安装在/usr/local/include头文件下，库文件就被默认安装在/usr/local/lib下sudo ./b2 ins...
单例模式——饿汉模式
pigff的博客
08-22 2万+
所谓的单例模式，就是设计一个类，它在整个程序中只能有一个该类的实例存在，这就是单例模式。 C++实现单例模式的一般方法是将构造函数，拷贝构造函数以及赋值运算符函数声明成private，从而禁止他人创建实例。否则如果上面三者不为私有，那么他人就可以调用上面的三个函数来创建实例，就没法实现单例模式。但是我们总归是要创建一个类的，我们可以提供一个public的静态方法来帮助我们获得这个类唯一的一个实例...
单例模式——懒汉模式
pigff的博客
08-22 1万+
上一篇文章讲到了单例模式的饿汉模式，这一篇来讨论一下单例模式的懒汉模式。 所谓懒汉模式，就是像一个懒汉一样，需要用到创建实例了程序再去创建实例，不需要创建实例程序就“懒得”去创建实例，这是一种时间换空间的做法，这体现了“懒汉的本性”。 如果有多个线程，同时调用了获取实例，那么可能就会产生多个实例，那么这就不是我们的单例模式了。所以我们需要做一些事情才能保证我们是一个单例类。 额当然，我们先来...
模拟stl类的list
06-12
List是一个双向链表，我们可以通过自己实现节点类和链表类来模拟这个数据结构。 首先，我们需要定义一个节点类，包含前驱节点指针、后继节点指针、以及存储数据的成员变量。代码如下： ``` template class ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值