C++STL之list容器

最新推荐文章于 2024-02-03 19:38:44 发布

不熬夜不抽烟不喝酒

最新推荐文章于 2024-02-03 19:38:44 发布

阅读量660

点赞数 8

文章标签： list 算法 c++ Powered by 金山文档

本文链接：https://blog.csdn.net/phenix_417/article/details/128546704

版权

一：list特性

list为带哨兵位双向循环链表，支持任意位置的插入和删除。

与（array，vector，deque）相比，list的移除元素效率更高。

最大缺陷是不支持[]重载，不支持随机访问，只能通过迭代器进行线性开销的迭代。

二：list的排序

list无法使用算法库中的sort排序，算法库的sort底层是快排，需要三数取中，需要传入随机访问迭代器，所以list不适用。但是list的类域中自身提供了一种sort排序，底层是归并排序。

通过图片分析，list的排序比vector调用算法库中的排序效率低，甚至比先将list数据拷贝给vector，再调用算法库的排序的效率还要低。

三：迭代器

1：迭代器失效

erase迭代器失效

insert迭代器不失效

2：迭代器种类

单向迭代器，只能++，如单链表和哈希表。

双向迭代器，支持++和--，如双向循环链表

随机访问迭代器，支持++--和+-，如vector和string。

4：迭代器的价值

使用封装，不能暴露底层的实现细节

提供统一的访问方式，降低使用成本，这也是STL设计巧妙之处。

5：模拟实现

5.1：原生指针迭代器和封装迭代器类

vector和string在物理空间上是连续的，我们之前模拟实现的时候，采用typedef将原生指针定义为迭代器，vector和string是双向迭代器，迭代器的++和--都是跨过一个对象的大小，也就是T的大小。因为在物理空间连续，所以可以直接用原生指针。

但是list在物理空间上不连续，如果用原生指针，因为不清楚前后节点在物理空间上谁是前谁是后，所以用原生的++--就无法访问到下一个节点，因此我们可以使用封装+运算符重载实现迭代器。

对于每一个节点，在C语言的时候是用struct，在这里因为不知道节点是该给公共权限还是私有，所以也直接设计成struct。

    template<class T>
    struct list_node
    {
        list_node<T>* prev;
        list_node<T>* next;
        T _data;
        //构造函数
        list_node(const T& x)
            :prev(nullptr)
            ,next(nullptr)
            ,_data(x)
        {}
    };

迭代器代码

    template<class T,class Ref, class Ptr>
    struct __list_iterator//采用封装迭代器的方式
    {
        typedef list_node<T> node;
        typedef __list_iterator<T, Ref, Ptr> Self;
        node* pnode;//表示当前迭代器自己指向的节点
        __list_iterator(node* p)
            :pnode(p)
        {}
        Ptr operator->()
        {
            return &pnode->_data;
        }
        Self& operator++()
        {
            //隐含this
            pnode = pnode->next;
            return *this;
        }
        Ref operator*()
        {
            return pnode->_data;
        }
        bool operator!=(const Self& it)
        {
            return pnode != it.pnode;
        }
    };

迭代器模板中的Ref和Ptr后续讲解。迭代器类中设计好相关运算符的重载即可。

5.2：list类初步代码

template<class T>
    class list
    {
        typedef list_node<T> node;
    public:
        typedef __list_iterator<T,T&,T*> iterator;
        typedef __list_iterator<T, const T&,const T*> const_iterator;

5.3：const迭代器

const迭代器错误写法

typedef __list_iterator<T> iterator;
const list<T>::iterator it=lt.begin();

如果给it迭代器添加const权限，那么it就无法更改，也就是it无法++--，这样显然不行。

因此我们可以考虑给迭代器类模板添加第二个参数。在list类模板中将普通迭代器和const迭代器使用同一个类模板创建2种类型，也就是第二个参数分别传普通的T和const T。因为const迭代器无法修改迭代器所指向的内容，因此传引用没有拷贝开销，所以第二个参数分别传T&和const T&。

因为多了一个参数，比如设计*重载的时候，返回值需要设置为__list_iterator<T, Ref>&,这样名字过长，因此我们可以这样。(Ptr下面再讲)

typedef __list_iterator<T, Ref, Ptr> Self;

这里非const和const迭代器采用添加Ref参数的好处是，如果不这样写，就需要在迭代器类模板中分别实现每个函数的const和非const版本，这样一来代码重复量太大，不美观。

5.4：->重载

list类模板中，T是对象的类型，如果T是struct类型，想要通过迭代器解引用访问T对象的数据，就必须在迭代器类中提供->重载。

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

这里使用Ptr，是考虑有const和非const的迭代器，在list中我们就可以这样传参。

        typedef __list_iterator<T,T&,T*> iterator;
        typedef __list_iterator<T, const T&,const T*> const_iterator;

因为如果访问struct的成员，需要使用->,而struct指针可以做到，因此第三个参数要设计成指针形式，对于非const传T*，对于const传const T*，因此在迭代器的类模板中就可以添加第三个参数Ptr，表示指针，那么->重载的返回值就可以为Ptr。

        list<Pos>::const_iterator it = lt.begin();
        while (it != lt.end())
        {
            //it->_row++;

            cout << it->_row << ":" << it->_col << endl;

我们一般可能遇到这种情景，为什么->这样重载就可以访问到数据呢？

it->我们知道应该是it.operator->(),这样的返回值是Pos*，Pos*_row这如何访问数据？

实际上，这里it->_row的本来面貌是it->->_row,这样就容易懂了，Pos*->_row就是结构体指针访问到数据，而编译器为了可读性，在这里省略了一个->，因此这里比较难懂。

5.5：模拟总代码

    template<class T>
    class list
    {
        typedef list_node<T> node;
    public:
        typedef __list_iterator<T,T&,T*> iterator;
        typedef __list_iterator<T, const T&,const T*> const_iterator;

        list()
        {
            empty_initialize();
        }
        iterator begin()
        {
            //返回的是迭代器
            //用匿名对象
            return iterator(_head->next);
        }
        iterator end()
        {
            //返回的是迭代器
            //用匿名对象
            //end是最后一个节点的下一个位置
            return iterator(_head);
        }
        void push_back(const T& x)
        {
            insert(end(), x);
        }
        void push_front(const T& x)
        {
            insert(begin(), x);
        }
        void pop_front()
        {
            erase(begin());
        }
        void pop_back()
        {
            erase(--end());
        }
        iterator insert(iterator pos, const T& x)
        {
            node* newnode = new node(x);
            node* cur = pos.pnode;//记录当前位置
            node* prev = pos.pnode->prev;
            prev->next = newnode;
            newnode->prev = prev;
            newnode->next = cur;
            cur->prev = newnode;
            ++size;
            return iterator(newnode);
            
        }
        iterator erase(iterator pos)
        {
            node* prev = pos.pnode->prev;
            node* next = pos.pnode->next;
            prev->next = next;
            next->prev = prev;
            delete pos.pnode;
            --size;
            return iterator(next);
        }
        list(const list<T>& lt)
        {
            empty_initialize();
            list<T> temp(lt.begin(), lt.end());
            swap(temp);//临时对象出函数自动调用析构，注意先给原先链表初始化，否则随机值给了temp，出错
        }
        list<T>& operator=(list<T> lt)
        {
            //千万别传引用
            swap(lt);
        }
        template<class InputIterator>
        list(InputIterator first, InputIterator last)
        {
            empty_initialize();
            while (first != last)
            {
                push_back(*first);
                ++first;
            }
        }
        void empty_initialize()
        {
            _head = new node(T());
            _head->next = _head;
            _head->prev = _head;

            size = 0;
        }
        size_t getsize()const
        {
            return size;
        }
        bool empty()const
        {
            return size == 0;
        }
        ~list()
        {
            clear();
        }
        void clear()
        {
            iterator it = begin();
            while (it != end())
            {
                it = erase(it);
            }
        }
        void swap(list<T>& lt)
        {
            std::swap(_head, lt._head);
            std::swap(size, lt.size);
            
        }
    private:
        node* _head;//哨兵位的头结点
        size_t size;
        
    };

5.6：拷贝构造现代写法

和前面一样，直接使用算法库的swap是一个深拷贝，代价太大，所以我们可以换个思路使用算法库的swap交换头节点即可，因为list只要头结点知道就可以访问下面的数据。

        void swap(list<T>& lt)
        {
            std::swap(_head, lt._head);
            std::swap(size, lt.size);
            
        }

拷贝构造比如lt1(lt2)，目的是将lt2的内容给lt1，不能改变lt2的内容，因此需要传const&

拷贝构造不能直接传值传参，必须用传引用传参，否则无限递归。

        list(const list<T>& lt)
        {
            empty_initialize();
            list<T> temp(lt.begin(), lt.end());
            swap(temp);//临时对象出函数自动调用析构，注意先给原先链表初始化，否则随机值给了temp，出错
        }
            //构造函数
        template<class InputIterator>
        list(InputIterator first, InputIterator last)
        {
            empty_initialize();
            while (first != last)
            {
                push_back(*first);
                ++first;
            }
        }

而如果通过临时对象构造一个lt2，可以再设计一个前后迭代器的构造函数,一开始设计的时候是没有empty这个函数的，因为如果将list初始化的代码直接放在构造函数中，这里我们设计拷贝构造的时候，lt1对象还没有实例化，仍然是一个类，所以不会去调用构造函数，所以头节点就是一个随机值。所以如果将随机值交换给temp，temp出了当前函数作用域后自动调用析构，析构的就是随机值，因此我们需要将初始化的代码单独使用一个empty函数。

5.7：=重载现代写法

和之前一样，用传值传参，不改变形参的特性。

        list<T>& operator=(list<T> lt)
        {
            //千万别传引用
            swap(lt);
        }

四：list和vector的区别

底层结构：vector是动态顺序表，连续空间，list是带头双向循环链表，物理空间不连续。

随机访问：vector支持[]重载随机访问，效率O（1），list不支持随机访问，访问效率O（N）。

插入和删除：vector任意位置插入和删除的效率比较低(尤其是前中部分元素），需要挪动数据，时间复杂度为O（N），插入的时候需要增容，增容是异地扩容，拷贝元素，释放旧空间，效率更低。list任意位置插入和删除元素效率高，效率为O（1），不需要挪动数据。

空间利用率：vector底层为连续空间，不易造成内存碎片，空间利用率高，高速缓存命中率高，list底层节点动态开辟，小节点容易造成内存碎片，空间利用率低，高速缓存命中率低。

迭代器：vector是原生态指针，list采用封装+函数重载。

迭代器失效：vector的insert可能导致扩容，迭代器失效，erase也会导致当前pos位置的迭代器失效。list的insert迭代器不会失效，erase导致当前迭代器失效。

使用场景：vector适用于高效存储，随机访问，不关心插入删除效率。list适用于大量插入和删除操作，不关心随机访问。

不熬夜不抽烟不喝酒

关注

8
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
7
评论
C++STL之list容器

C++STL之list容器
复制链接

扫一扫