波奇学C++:stl的list模拟实现

list是双向带头链表。所以迭代器end()相当于哨兵卫的头。

list不支持+和[]重载,原因在于list空间不是连续的,+和[]的代价比较大。

访问第n个节点,只能用for循环,++来实现

list<int> l;
l.push_back(0);
l.push_back(1);
l.push_back(2);
l.push_back(3);
auto li=l.begin();
//访问第3个节点
for(size_t i=0;i<3;i++)
{
    li++;
}

list的insert不会失效,但是erase会迭代器失效。

list是双向迭代器

迭代器可以简单分为:单向迭代器(forward)++,双向迭代器(bidirectional) ++/-- 随机迭代器(random acess)+/-/++/--

不同的数据结构的迭代器决定了可以使用不同的算法。其中随机迭代器代器的范围最广,可以用的算法最多。

std:sort只能是随机迭代器用,list不能使用,list也有自己的sort算法但是效率并不高。

list实现

大概思路先不考虑迭代器,链表分为两个类,一个类表示节点,另外一个类表示链表。

节点模板类

template<class T>
	struct list_node
	{
		list_node<T>* _next;
		list_node<T>* _prev;
		T _val;
		list_node(const T& val = T())
			:_next(nullptr)
			,_prev(nullptr)
			,_val(val)
		{

		}
	};

这里有个注意的点,模板类的类名不是类型,list_node只是类名,不是对应的自定义类型,所以是

list_node<T>* _next;而不是list_node* _next。

编译器优化 

拷贝构造写类名也可以

模拟实现的代码

namespace my_list
{
    template<class T> 
    struct list_node
    {

        list_node<T>* _prev;
        list_node<T>* _next;
        T _val;
        list_node(const T& val=T())
            :_next(nullptr)
            ,_prev(nullptr)
            ,_val(val)
        {}
    };
    template<class T,class Ref,class Ptr>
    struct __list_iterator
    {
        typedef list_node<T> Node;
        typedef __list_iterator<T, Ref,Ptr> self;
        Node* _node;
        __list_iterator(Node* node)
            :_node(node)
        {}
        Ref operator*()
        {
            return _node->_val;

        }
        self& operator++()
        {
            _node = _node->_next;
            return *this;
        }
        self& operator--()
        {
            _node = _node->_prev;
            return *this;
        }
        bool operator!=(const self& it)
        {
            return _node != it._node;
        }
        self operator++(int)
        {
            self tmp(*this);
            _node = _node->_next;
            return tmp;
        }
        Ptr operator->()
        {
            return &_node->_val;
        }
    };
    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;
        iterator begin()
        {
            return _head->_next; 
        }
        iterator end()
        {
            return _head;
        }
        const_iterator const_begin()
        {
            return _head->_next;
        }
        const_iterator const_end()
        {
            return _head;
        }
        void empty_init()
        {
            _head = new Node;
            _head->_next = _head;
            _head->_prev = _head;
        }
        list()
        {
            empty_init();
        }
        ~list()
        {
            clear();
            delete _head;
            _head = nullptr;
        }
        list(const list<T>& lt)
        {
            empty_init();

            for (auto& e : lt)
            {
                push_back(e);
            } 
        }
        void swap(list<T>& lt)
        {
            std::swap(_head, lt._head);
            std::swap(_size, lt._size);
        }
        list<T>& operator=(list<T> lt)
        {
            swap(lt);
            return *this;
        }
        ~list()
        {
            clear();
            delete _head;
            _head = nullptr;
        }
        void push_back(const T& x)
        {/*
            Node* tail =_head->_prev;
            Node* newnode = new Node(x);
            tail->_next = newnode;
            newnode->_prev = tail;
            newnode->_next = _head;
            _head->_prev = newnode;*/
            insert(end(), x);
        }
        void push_front(const T& x)
        {
            insert(begin(), x);
        }
        void pop_back()
        {
            erase(--end());
        }
        void pop_begin()
        {
            erase(begin());
        }
        iterator insert(iterator pos, const T& x)
        {
            Node* cur = pos._node;
            Node* prev = cur->_prev;
            Node* newnode = new Node(x);
            prev->_next = newnode;
            newnode->_next = cur;
            cur->_prev = newnode;
            newnode->_prev = prev;
            return newnode;
        }
        iterator erase(iterator pos)
        {
            assert(pos != end());
            Node* cur = pos._node;
            Node* prev = cur->_prev;
            Node* next = cur->_next;
            prev->_next = next;
            next->_prev = prev;
            delete cur;
            return next;
        }
        void clear()
        {
            iterator it = begin();
            while (it != end())
            {
                it=erase(it);
            }
        }
        size_t size()
        {
            size_t sz = 0;
            iterator it = begin();
            while (it != end())
            {
                sz++;
            }
            return sz;
        }
    private:
        Node* _head;
        Node* _tail;
    };
}

  • 2
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值