前言
感觉STL 的list中很多成员函数就是Leetcode上关于链表的一些题,而哨兵节点的思想对于一些需要双向链表的题也很好用,比如LRU算法;anyway,看源码还是能学到很多东西的;
链表base体和迭代器
#include<iostream>
using namespace std;
namespace mystd
{
template<typename T>
struct __list_node {
void* next;
void* prev;
T data;
__list_node(T x) : data(x), next(nullptr), prev(nullptr){}
};
template<typename T>
struct __list_iterator {
typedef __list_iterator<T> iterator;
typedef __list_iterator<T> self;
typedef __list_node<T>* link_type;
link_type node;
self& operator++()
{
node = (link_type)(*node).next);
return *this;
}
self operator++(int)
{
self tmp = *this;
++*this;
return tmp;
}
/*--重载 == 重载 !=重载,甚至是 > <重载*/
};
}
list类
注意STL里面的end()统一是容器最后一个元素的下一个位置,并不存放元素,而这在链表里就体现为哨兵节点;同时,一般像begin()这类的函数要实现const版本和非const版本,我这里只给出const版本,如果没有 + const,那么如果调用者 这样调用就会出错:const std::list<T>::iterator it = it.begin();
template<typename T>
struct list {
protected:
typedef __list_node<T> list_node;
public:
typedef list_node* link_type;
typedef __list_iterator<T> iterator;
typedef int size_t;
typedef T& reference;
protected:
link_type node;
void empty_initialize()
{
node = new link_type();
node->next = node;
node->prev = prev;
}
public:
list() { empty_initialize(); }
/*一般同时实现const版本和非const版本,函数体没有变化,这是为了避免用户用一个const实例来调用成员函数出错的问题*/
iterator begin() const { return (link_type)((*node).next); }
iterator end() const { return node; }//左闭右开,最后一个元素的下一个节点
reference front() const { return *begin(); }
reference back() const { return *(--end()); }
bool empty() const { return node->next == node; }
size_t size() const
{
size_t len;
iterator i = begin();
for (; i != end(); ++i)
len++;
return len;
}
增删改查
主要就是insert和erase,其他的增删都可以用这两个基础的API;包括范围插入和范围删除,不过是insert和erase 加循环而已
public:
iterator insert(iterator pos, const T& x)
{
link_type tmp = new link_type(x);
tmp->next = pos.node;
tmp->prev = pos.node->prev;
(link_type(pos.node->prev))->next = tmp;//void*类型的再次使用时强制类型转换
pos.node->prev = tmp;
return tmp;
}
iterator erase(iterator pos)
{
link_type next_node = link_type(pos.node->next);
link_type prev_node = link_type(pos.node->prev);
prev_node->next = next_node;
next_node->prev = prev_node;
delete pos.node;
return iterator(next_node);//向外转换
}
void push_front(const T& x) { insert(begin(), x); }
void push_back(const T& x) { insert(end(), x); }
void pop_front() { erase(begin()); }
void pop_back() { iterator tmp = end(); erase(--tmp); }
void resize(size_t new_size, const T& x)
{
iterator i = begin();
size_t len = 0;
for (; i != end() && len < new_size; ++i, ++len)
;//什么都不做,直到条件之一满足
if (len == new_size)//说明new_size < old_size
erase(i, end());
else
{
for (; len < new_size; ++len)
push_back(x);
}
}
结束语
list还是挺简单的,主要是双向链表的哨兵思想,以及多层struct时,最里层若有void*类型的指针,在使用二级link_type的时候需要强制类型转换,如果不是看了这部分源码我还真不清楚;