基础数据结构之数组与链表（五）

本篇主要介绍一种重要的链表——“双向链表”（Doubly Linked Lists）。

双向链表，顾名思义，它既可以从head开始正向遍历链表，也可以从tail开始反向遍历链表。双向链表的节点包含两个指针，一个指向下一个节点（successor，同单链表），另一个指向前一个节点（predecessor），因此，也可以将它看作是两个迭代方向不同的叠在一起的单链表。如下图a。



以上是几种双向链表的结构图，包括空链表的状态。

其中，图a是最简单的一种双向链表，它包含两个指针，head指向第一个元素，tail指向最后一个元素，完全可以看作是两个走向不同的单链表的叠加。

图b引入了sentinel节点（不是指针）。它是一种编程技巧，前面在介绍单链表的时候已经展示了sentinel节点的作用，无需特殊处理head。

图c是一个可双向循环的循环链表。

图d是带sentinel节点的循环链表。

下面选取图a的结构实现一个双向链表。

#ifndef DOUBLY_LINKED_LIST_H
#define DOUBLY_LINKED_LIST_H

#include <stdexcept>

namespace FoundationalDataStructure
{
// forward declaration
template <typename T>
class DoublyLinkedList;

template <typename T>
class Node
{
public:
T const & Datum() const;
Node const * Prev() const;
Node const * Next() const;

friend DoublyLinkedList<T>;

private:
T datum;
Node * prev;
Node * next;

Node(T const &, Node *, Node *);
};

template <typename T>
class DoublyLinkedList
{
public:
DoublyLinkedList();
~DoublyLinkedList();

DoublyLinkedList(DoublyLinkedList const &);
DoublyLinkedList & operator=(DoublyLinkedList const &);

Node<T> const * Head() const;
Node<T> const * Tail() const;

bool IsEmpty() const;
operator bool() const;    // operator bool() const { return !IsEmpty(); }
T const & First() const;
T const & Last() const;

void Prepend(T const &);
void Append(T const &);
void Extract(T const &);
void Purge();
void InsertAfter(Node<T> const *, T const &);
void InsertBefore(Node<T> const *, T const &);
private:
Node<T> * head;
Node<T> * tail;
};

//////////////////////////////////////////////////Implementation/////////////////////////////////////////////////////////////////////
template <typename T>
Node<T>::Node(T const & _datum, Node * _prev, Node * _next)
: datum(_datum)
, prev(_prev)
, next(_next)
{}

template <typename T>
T const & Node<T>::Datum() const
{
return datum;
}

template <typename T>
Node<T> const * Node<T>::Prev() const
{
return prev;
}
template <typename T>
Node<T> const * Node<T>::Next() const
{
return next;
}

template <typename T>
DoublyLinkedList<T>::DoublyLinkedList()
: head(NULL)
, tail(NULL)
{}

template <typename T>
void DoublyLinkedList<T>::Purge()
{
// The main loop of the Purge function simply traverses all the elements of linked list, deleting each of them one-by-one.
while (head)
{
Node<T> * temp(head);
head = head->next;    // move head pointer
delete temp;
temp = NULL;
}
tail = NULL;
}

template <typename T>
DoublyLinkedList<T>::~DoublyLinkedList()
{
Purge();
}

template <typename T>
Node<T> const * DoublyLinkedList<T>::Head() const
{
return head;
}

template <typename T>
Node<T> const * DoublyLinkedList<T>::Tail() const
{
return tail;
}

template <typename T>
bool DoublyLinkedList<T>::IsEmpty() const
{
return (!head || !tail);
}

template <typename T>
DoublyLinkedList<T>::operator bool() const
{
return !IsEmpty();
}

template <typename T>
T const & DoublyLinkedList<T>::First() const
{
if (!head)
throw std::domain_error("List is empty");

return head->datum;
}

template <typename T>
T const & DoublyLinkedList<T>::Last() const
{
if (!tail)
throw std::domain_error("List is empty");

return tail->datum;
}

template <typename T>
void DoublyLinkedList<T>::Prepend(T const & item)
{
Node<T> * const temp = new Node<T>(item, NULL, head);
if (!head)
tail = temp;    // list is empty
else
head->prev = temp;

head = temp;    // move head to the front of the new list
}

template <typename T>
void DoublyLinkedList<T>::Append(T const & item)
{
Node<T> * const temp = new Node<T>(item, tail, NULL);
if (!tail)
head = temp;    // list is empty
else
tail->next = temp;    // insert temp at the end of the list

tail = temp;    // move tail to the end of the new list
}

template <typename T>
void DoublyLinkedList<T>::Extract(T const & item)    // pass by reference or value ?
{
if (!head)
throw std::domain_error("list is empty");

auto ptr = head;
while (ptr != NULL)
{
if (ptr->datum == item)
{
auto temp = ptr;    // backup

if (ptr == head)
{
if (ptr == tail)
tail = NULL;
else
ptr->next->prev = NULL;

ptr = ptr->next;
head = ptr;
}
else
{
if (ptr == tail)
tail = ptr->prev;
else
ptr->next->prev = ptr->prev;     // bridget over ptr

ptr->prev->next = ptr->next;    // bridget over ptr
ptr = ptr->next;                // move ptr
}

delete temp;
temp = NULL;
continue;    // break; for the first one
}
ptr = ptr->next;
}
}

template <typename T>
DoublyLinkedList<T>::DoublyLinkedList(DoublyLinkedList const & linkedList)
: head(NULL)
, tail(NULL)
{
for (auto ptr = linkedList.Head(); ptr != NULL; ptr = ptr->next)
Append(ptr->datum);
}

template <typename T>
DoublyLinkedList<T> & DoublyLinkedList<T>::operator=(DoublyLinkedList const & linkedList)
{
if (&linkedList != this)
{
Purge();
for (auto ptr = linkedList.Head(); ptr != NULL; ptr = ptr->next)
Append(ptr->datum);
}
return *this;
}

template <typename T>
void DoublyLinkedList<T>::InsertAfter(Node<T> const * arg, T const & item)
{
Node<T> * ptr = const_cast<Node<T>*> (arg);
if (!ptr)
throw std::invalid_argument("invalid position");

Node<T> * const temp = new Node<T>(item, ptr, ptr->next);
if (ptr->next)
ptr->next->prev = temp;

ptr->next = temp;
if (tail == ptr)
tail = temp;
}

template <typename T>
void DoublyLinkedList<T>::InsertBefore(Node<T> const * arg, T const & item)
{
Node<T> * ptr = const_cast<Node<T>*> (arg);
if (!ptr)
throw std::invalid_argument("invalid position");

Node<T> * const temp = new Node<T>(item, ptr->prev, ptr);
if (ptr->prev)
ptr->prev->next = temp;

ptr->prev = temp;
if (head == ptr)
head = temp;
}
} // namespace FoundationalDataStructure

#endif    // DOUBLY_LINKED_LIST_H

注：

1，本文的节点与链表采用的是友元类的实现方式，也可以使用嵌套类的实现方式。

2，函数“operator bool() const; // operator bool() const { return !IsEmpty(); }”的声明和定义格式，以及类模版前缀的添加方式。