List复习

List的使用

1.push_back find insert  reverse splice
2.插入1 2 3 4 5
3.查找3的位置插入30
4.逆置reverse打印  sort排序
5.splice的使用  创建LT  7 8 9 插入到30后面
6.算法库里面的sort和list的sort---为什么需要两个？
        因为list用不了算法库里面的sort，调用sort对迭代器有要求。std::sort()它的时间复杂度是 O(n log n)，通常实现为快速排序，用于排序随机访问迭代器支持的数据结构。

        list::sort()它的时间复杂度也是 O(n log n)，但实现为归并排序，因为链表不支持随机访问，归并排序适合链表的特性。

list的sort效率低
单向迭代器：forward_list
双向迭代器：list
随机迭代器：vector
一般不使用list的sort算法因为效率特别低

list的模拟实现

模板

namespace OO
{
    // List的节点类
    template<class T>
    struct ListNode
    {};

    //List的迭代器类
    template<class T, class Ref, class Ptr>
    class ListIterator
    {
    public:
        ListIterator()
        {
        }
        operator*()
        {
        }
        operator->()
        {
        }
        operator++()
        {
        }
        operator++()
        {
        }
        operator--()
        {
        }
        operator--()
        {
        }
        operator!=()
        {
        }
        operator==()
        {
        }
    private:
    };

    //list类
    template<class T>
    class list
    {
    public:
        ///
        // List的构造
        list()
        {
            CreateHead();
        }
        //普通构造
        list(int n, const T& value = T())
        {
        }
        //迭代器区间构造
        template <class Iterator>
        list(Iterator first, Iterator last)
        {
        }
        //拷贝构造
        list()
        {
        }
        operator=()
        {
        }
        ~list()
        {
        }
        ///
        // List Iterator
        begin()
        {
        }
        end()
        {
        }
        begin()
        {
        }
        end()
        {
        }
        ///
        // List Capacity
        size()
        {
        }
        empty()
        {
        }
        // List Modify
        push_back()
        {
        }
        pop_back()
        {
        }
        push_front(const T& val)
        {
        }
        pop_front()
        {
        }
        // 在pos位置前插入值为val的节点
        insert()
        {
        }
        // 删除pos位置的节点，返回该节点的下一个位置
        erase()
        {
        }
        clear()
        {
        }
        swap()
        {
        }
    private:
        void CreateHead()
        {
        }
    };
}

实现 

为什么要重载->???

见下面的一个例子。

//迭代器为什么重载 -> 
struct AA
{
	int _a1;
	int _a2;
	AA(int a1 = 0, int a2 = 0)
		:_a1(a1)
		, _a2(a2)
	{}
};
//补充代码打印出lt中 _a1 : _a2 的值
void test2()
{
	list<AA> lt;
	lt.push_back(AA(1, 1));
	lt.push_back(AA(2, 2));
	lt.push_back(AA(3, 3));

	list<AA>::iterator it = lt.begin();
	while (it != lt.end())
	{
		补充代码
		//cout << it->_a1 << " : " << it->_a2 << endl;
		//it++;
	}
	cout << endl;
}

原因解释： 

while (it != lt.end())
{
	//引出迭代器为什么要进行->的重载
	// cout<< *it << endl; //如果只是解引用的话那么代码报错，因为模板参数是AA这是一个对象，cout没有重载不能直接打印对象
	//cout << (*it)._a1 << " " << (*it)._a2 << endl;//能正常打印

	cout << it->_a1 << " : " << it->_a2 << endl;
	//cout << it.operator->()->_a1 << endl; //同上代码
	++it;
}

实现list 模板三参数形式.

namespace OO
{
    // List的节点类
    template<class T>
    struct ListNode
    {
        ListNode<T>* _next;
        ListNode<T>* _prev;
        T _val;
        ListNode(const T& val = T())
            :_next(nullptr),_prev(nullptr),_val(val)
        {}
    };

    //List的迭代器类
    template<class T, class Ref, class Ptr>
    class ListIterator
    {
        typedef ListNode<T> Node;
        typedef ListIterator<T, Ref, Ptr> Self;
    public:
        ListIterator(Node* node = nullptr)
            :_node(node)
        {
        }
        Ref operator*()
        {
            return _node->_val;
        }
        Ptr operator->()
        {
            return &_node->_val;
        }
        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& l)
        {
            return _node != l._node;
        }
        bool operator==(const Self& l)
        {
            return _node == l._node;
        }
    private:
        Node* _node;
    };

    //list类
    template<class T>
    class list
    {
        typedef ListNode<T> Node;
        typedef ListIterator<T, T&, T*> iterator;
        typedef ListIterator<T, const T&, const T*> const_iterator;

    public:
        ///
        // List的构造
        list()
        {
            CreateHead();
        }
        list(int n, const T& value = T())
        {
            CreateHead();
            _head->_val = value;
            Node* cur = _head;
            for (int i = 0; i < n-1; ++i)
            {
                Node* newnode = new Node;
                newnode->_val = T;
                cur->_next = newnode;
                newnode->_prev = cur;
                newnode->_next = nullptr;

                cur = cur->_next;
            }
        }
        template <class Iterator>
        list(Iterator first, Iterator last)
        {
            CreateHead();
            while (first != last)
            {
                push_back(*first);
                ++first;
            }
        }
        list(const list<T>& l)
        {
            CreateHead();
            list<T> tmp(l.begin(), l.end());
            swap(tmp);
        }
        list<T>& operator=(const list<T> l)
        {
            swap(l);
            return *this;

        }
        ~list()
        {
            clear();
            delete _head;
            _head = nullptr;
        }
        ///
        // List Iterator
        iterator begin()
        {
            return iterator(_head->_next);
        }
        iterator end()
        {
            return iterator(_head);
        }
        const_iterator begin()const
        {
            return const_iterator(_head->_next);
        }
        const_iterator end()const
        {
            return const_iterator(_head);
        }
        ///
        // List Capacity
        size_t size()const
        {
            return _size;
        }
        bool empty()const
        {
            return _size == 0;
        }
        // List Modify
        void push_back(const T& val) 
        { 
            insert(end(), val); 
        }
        void pop_back() 
        { 
            erase(--end()); 
        }
        void push_front(const T& val) 
        { 
            insert(begin(), val); 
        }
        void pop_front() 
        {
            erase(begin()); 
        }
        // 在pos位置前插入值为val的节点
        iterator insert(iterator pos, const T& val)
        {
            Node* cur = pos._node;
            Node* prev = pos->_prev;
            Node* newnode = new Node(val);

            prev->_next = newnode;
            newnode->_prev = prev;
            newnode->_next = cur;
            cur->_prev = newnode;
        }
        // 删除pos位置的节点，返回该节点的下一个位置
        iterator erase(iterator pos)
        {
            assert(pos != end());
            Node* prev = pos->_prev;
            Node* next = pos->_next;

            prev->_next = next;
            next->_prev = prev;

            delete pos._node;
            return iterator(next);
        }
        void clear()
        {
            iterator it = begin();
            while (it != end())
            {
                erase(it++);
            }
        }
        void swap(list<T>& l)
        {
            std::swap(_head,l.head);
        }
    private:
        void CreateHead()
        {
            _head = new Node;
            _head->_next = nullptr;
            _head->_prev = nullptr;
            _size = 0;
        }
        Node _head;
        size_t _size;
    };
}

测试

void test()
{
	OO::list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(7);

	OO::list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
}
int main()
{
	test();
	return 0;
}