list 链表

#include <list>
#include <iostream>
using std::list;

/*
    双向环状链表
    //每一个结点 一个数据域 一个前驱指针 一个后驱指针
    随机插入方便0(1)  随机访问效率低0(n)
*/

bool foo(int a) {
    return a % 2 == 0;
}

bool foo2(int a) {
    return a == 0;
}

int main()
{
    //初始化列表
    list<int> list_test1;
    list<int> list_test2(5);//5个结点的链表 默认值是0
    list<int> list_test3(2,3);
    list<int> list_test4(list_test3);
    list<int> list_test5= list_test4;

    //末尾插入
    list_test1.push_back(10);
    list_test1.push_back(20);
    list_test1.push_back(30);

    //末尾删除
    list_test1.pop_back();

    //和vector的区别
    //排序
    list_test1.sort();
    //前侧插入
    list_test1.push_front(40);
    //前侧删除
    list_test1.pop_front();

    //merge 合并两个有序链表再排序
    list_test1.merge(list_test2);

    //清除指定值的元素 remove
    list_test1.remove(3);

    //清除满足条件的元素 remove_if  参数是返回bool的函数指针
    list_test1.remove_if(foo);
    list_test1.remove_if(foo2);//条件返回值必须是bool

    //splice 拼接结合

    //unique() 删除重复值，保证唯一
    list_test1.unique();

    for (auto& i : list_test1) {
        std::cout << i << std::endl;
    }
}

自写

#pragma once
#include <memory>

using namespace std;
/*
list结点

    |next|---->|next|---->|next|
    |prev|<----|prev|<----|prev|
    |data|       |data|      |data|

*/
template <typename T>
struct __list_node
{
    typedef __list_node* list_node_pointer;
    list_node_pointer    next;
    list_node_pointer    prev;
    T                    data;
};

/*
list迭代器 操作容器
*/
template <typename T>
struct __list_iterator
{
    typedef __list_iterator<T>    self;
    typedef __list_node<T> *    link_type;

    link_type ptr;//指向list结点的指针 头指针

    __list_iterator(link_type p = nullptr) :ptr(p) {}//构造
    __list_iterator(const self& that) :ptr(that.ptr) {}//拷贝构造

    bool operator==(const self& that) const
    {
        return this->ptr == that.ptr;
    }
    bool operator!=(const self& that) const
    {
        return this->ptr != that.ptr;
    }
    T& operator*()const
    {
        return ptr->data;
    }
    T* operator->()const
    {
        return &(operator*());
    }
    //迭代器前++ 返回下一个结点
    self& operator++()
    {
        ptr=ptr->next;//指针指向下一个结点
        return *this;
    }

    //后++ 先返回后自增
    self operator++()
    {
        self tmp = *this;
        ++*this;//调用了前面写的前++的操作
        return tmp;
    }

    //迭代器前-- 返回上一个
    self& operator--()
    {
        ptr = ptr->prev;//指针指向上一个结点
        return *this;
    }

    //后-- 先返回后自减
    self operator--()
    {
        self tmp = *this;
        --*this;
        return tmp;
    }
};

/*
list
*/
template <typename T>
class MyList
{
protected:
    typedef __list_node<T> list_node;
    //空间配置器 内存池实现小块内存的分配机制
    /*
    大概实现
    一级空间配置器   直接封装了malloc free
    二级空间配置器   内存池  自有链表
    实现原理 用户申请内存》128？ 一级:二级

    */
    allocator<list_node> nodeAllocator;

    typedef    T                    value_type;
    typedef    value_type*            pointer;
    typedef    const value_type*    const_pointer;
    typedef    value_type&            reference;
    typedef    size_t                size_type;

public:
    typedef list_node*            link_type;
    typedef __list_iterator<T>    iterator;

protected:
    //只要一个结点指针可以表示整个list
    link_type node; //指向list结点的指针    头指针

    //空间配置器  
    //分配新节点（内存） 不会进行构造
    list_node alloc_node()
    {
        return = nodeAllocator.allocate(sizeof(list_node));
    }

    //释放结点不会进行析构
    void dealloc_node(list_node p) 
    {
        nodeAllocator.deallocate(p);
    }

    //分配新结点（内存） 用value构造新节点里面内容
    list_node alloc_dtor_node(const T& value) 
    {
        //分配结点空间
        link_type p = alloc_node();
        //构造结点内容
        nodeAllocator.construct(&p->data, value);
    }

    //析构整个结点 释放内存
    void dealloc_dtor_node(list_node p)
    {
    
    }

    //空的初始化
    void empty_init()
    {
        node = alloc_node();//分配一个结点空间 让node指向他
        node->prev = node;//指向他自己
        node->next = node;
    }
public:
    MyList()//链表初始化
    {
        empty_init（）
    }
    ~MyList();

    iterator begin()
    {
        return node->next;
    }
    iterator begin() const
    {
        return node->next;
    }
    iterator end()
    {
        return node;
    }
    iterator end() const
    {
        return node;
    }

    bool empty()const
    {
        return node == node->next;//结点指向他自身
        //return node== node->prev;
    }

    iterator insert(iterator pos, const T& value)
    {
        //先创造一个结点
        link_type tmp = alloc_dtor_node(value);
        //寻找位置插入
        node->next = pos.node;
        node->prev = pos.prev;

        pos.node->prev->next = tmp;
        pos.node->prev = tmp;
    
        return tmp
    }

    void push_back(const T& value)
    {
        insert(end(), value);
    }
private:

};