C++之list类及模拟实现

list的介绍

list的模拟实现

定义节点

有关遍历的重载运算符

list的操作实现

（1）构造函数

(2)拷贝构造函数

（3）赋值运算符重载函数=

（4）析构函数和clear成员函数

（5）尾插/头插和尾删/头删

（6)size成员函数

（7）在任意位置插入 (insert)

（8）任意位置删除（erase）

（9）迭代器

完整代码展示

vector和list的比较

1.排序

(1)list和vector排序

（2）list copy vector sort copy list sort和list

2.总结

list的介绍

（1）list类其实就是链表，但是它是双向链表。在数据结构中我们了解过双向链表的特点。下面我们回忆一下。

1.节点中具有两个指针。一个指针指向该节点的前一个节点，另一个指针指向该节点的下一个节点。

2.存在哨兵位。初始化的时候节点里的下一个节点和上一个节点都指向自己。

（2）STL中list的底层结构

list的模拟实现

定义节点

我们先定义双向链表的节点并初始化。

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

有关遍历的重载运算符

list容器有迭代器，那么就可以进行遍历，因此我们要可以++，--等运算符重载。而且在插入删除操作中我们常常需要 ‘.’ '->'对链表进行遍历。因为普通迭代器和const迭代器中只有operator*和operator->的返回值有区别，所以我们就在模板上多增加了两个模板参数。

代码如下：

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->_data;
		}
		Ptr operator->()
		{
			return &_node->_data;
		}
		//C++规定后缀调用需要有一个int型参数作为区分前缀与后缀调用的区别
		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& lt)
		{
			return _node == lt._node;//结构体变量用「.」来访问成员，而结构体指针用「->」来访问。
		}
		bool operator!=(const Self& lt)
		{
			return _node != lt._node;
		}
	};

list的操作实现

（1）构造函数

创建节点并把节点中的指针全部指向自己。

list()
{
_head = new node;
_head->_next = _head;
_head->_prev = _head;
}

(2)拷贝构造函数

先构造a1,再把lt中的资源尾插给a1。

      void empty_Init()
		{
			_head = new node;
			_head->_next = _head;
			_head->_prev = _head;
		}   
      //a1(a2)，a1是新建的
		list(const list<T>& lt)
		{
			empty_Init();
			for (auto& e : lt)
			{
				push_back(e);
			}
		}
     //initializer_list<T>
		list(std::initializer_list<T> lt)
		{
			empty_Init();
			for (auto& e : lt)
			{
				push_back(e);
			}
		}

两种拷贝构造的区别：

（3）赋值运算符重载函数=

        void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}
		//lt1=lt
		list<T>& operator=(list<T>& lt)
		{
			swap(lt);
			return *this;
		}

看到这个代码我们就会想为什么运算符重载中的形参不加const呢？如果加了const就像 void swap(*this,const list<T>& y)一样，这样是会报错的，两边类型不同，swap函数是一个函数模板，只有一个模板参数，那么有人会说把这个改成类型相同的不就行了。但是我们知道const list<T>& lt中const修饰list<T> 类型，则lt 引用的对象（即 list<T>）是常量对象，不能通过 lt 修改它的内容。它的值在初始化后就不能改变，而在swap函数中需要交换它们的资源，那么lt就需要改变。

（4）析构函数和clear成员函数

clear的作用只是清理链表的节点，只剩下哨兵位，并不会释放空间。

       ~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

（5）尾插/头插和尾删/头删

        void push_back(const T&x)
		{
			insert(end(), x);
		}
        void push_front(const T&x)
		{
			insert(begin(), x);
		}
		void pop_back()
		{
			erase(--end());//end()是哨兵位
		}
		void pop_front()
		{
			erase(begin());
		}

（6)size成员函数

        size_t size()const
		{
			return _size;
		}

（7）在任意位置插入 (insert)

         typedef list_iterator<T,T&,T*> iterator;   
         void insert(iterator pos, const T& x)
		{
			node* newnode = new node(x);
			node*pre = pos._node;
			node* prev = pre->_prev;
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = pre;
			pre->_prev = newnode;
			_size++;
		}

注意：pos的类型是list_iterator<T,T&,T*>,这个类中的成员变量只有_node,而_node的类型才是list_node,类型为list_node才有节点的成员变量。所以我们要node*pre = pos._node，而不能直接使用pos。

（8）任意位置删除（erase）

list中的erase也会有迭代器失效，所以我们需要返回下一个迭代器。

         typedef list_iterator<T,T&,T*> iterator; 
         iterator erase(iterator pos)
		{
			assert(pos != end());
			node* pre = pos._node;
			node* prev = pre->_prev;
			node* next = pre->_next;
			delete pre;
			prev->_next = next;
			next->_prev = prev;
			_size--;
			return iterator(next);
		}