基础数据结构之数组与链表（四）
本篇主要介绍“The Singly-Linked List with a sentinel”。它是单链表诸多变种类型中的一种，参考上一篇的图d。sentinel是一个空节点，始终占据链表的首位，并一直存在链表中（即使是空链表），它本身不存储数据。sentinel节点的设计，实际上是一种编程技巧，它可以简化链表的某些操作。比如，对Extract函数的简化。此外，该链表的尾节点的next指针不再指向NULL，而是指向sentinel，它是一个循环链表。
一、实现代码
#ifndef LINKED_LIST_H
#define LINKED_LIST_H
#include <stdexcept>
namespace FoundationalDataStructure
{
// forward declaration
template <typename T>
class LinkedList;
template <typename T>
class Node
{
public:
T const & Datum() const;
Node const * Next() const;
friend LinkedList<T>;
private:
T datum;
Node * next;
Node(T const &, Node *);
};
template <typename T>
class LinkedList
{
public:
LinkedList();
~LinkedList();
LinkedList(LinkedList const &);
LinkedList & operator=(LinkedList const &);
Node<T> const * Head() const;
Node<T> const * Tail() const;
Node<T> const * Sentinel() const;
bool IsEmpty() const;
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> sentinel;
Node<T> *& head; // the reference of a pointer
Node<T> * tail;
};
//////////////////////////////////////////////////Implementation/////////////////////////////////////////////////////////////////////
template <typename T>
Node<T>::Node(T const & _datum, Node * _next)
: datum(_datum)
, next(_next)
{}
template <typename T>
T const & Node<T>::Datum() const
{
return datum;
}
template <typename T>
Node<T> const * Node<T>::Next() const
{
return next;
}
template <typename T>
LinkedList<T>::LinkedList()
: sentinel({}, &sentinel)
, head(sentinel.next)
, tail(&sentinel)
{}
template <typename T>
void LinkedList<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 != &sentinel)
{
auto temp = head;
head = head->next; // move head pointer
delete temp;
}
tail = &sentinel;
}
template <typename T>
LinkedList<T>::~LinkedList()
{
Purge();
}
template <typename T>
Node<T> const * LinkedList<T>::Head() const
{
return head;
}
template <typename T>
Node<T> const * LinkedList<T>::Tail() const
{
return tail;
}
template <typename T>
Node<T> const * LinkedList<T>::Sentinel() const
{
return &sentinel;
}
template <typename T>
bool LinkedList<T>::IsEmpty() const
{
return head == &sentinel;
}
template <typename T>
T const & LinkedList<T>::First() const
{
if (head == &sentinel)
throw std::domain_error("List is empty");
return head->datum;
}
template <typename T>
T const & LinkedList<T>::Last() const
{
if (head == &sentinel)
throw std::domain_error("List is empty");
return tail->datum;
}
template <typename T>
void LinkedList<T>::Prepend(T const & item)
{
Node<T> * const temp = new Node<T>(item, head);
if (head == &sentinel)
tail = temp; // tail = &sentinel; before this operation
head = temp; // move head pointer
}
template <typename T>
void LinkedList<T>::Append(T const & item)
{
Node<T> * const temp = new Node<T>(item, &sentinel);
if (head == &sentinel)
head = temp; // the first node
else
tail->next = temp; // insert temp at the end of the list
tail = temp; // move tail to the end of the list
}
template <typename T>
void LinkedList<T>::Extract(T const & item) // pass by reference or value ?
{
if (head == &sentinel)
throw std::domain_error("list is empty");
auto ptr = head, prevPtr = &sentinel;
while (ptr != &sentinel)
{
if (ptr->datum == item)
{
if (ptr == tail)
tail = prevPtr;
auto temp = ptr;
prevPtr->next = ptr->next; // bridget over ptr
ptr = ptr->next;
delete temp;
continue;
}
ptr = ptr->next;
prevPtr = prevPtr->next;
}
}
template <typename T>
LinkedList<T>::LinkedList(LinkedList const & linkedList)
: sentinel({}, &sentinel)
, head(sentinel.next)
, tail(&sentinel)
{
for (auto ptr = linkedList.Head(); ptr != linkedList.Sentinel(); ptr = ptr->next)
Append(ptr->datum);
}
template <typename T>
LinkedList<T> & LinkedList<T>::operator=(LinkedList const & linkedList)
{
if (&linkedList != this)
{
Purge();
for (auto ptr = linkedList.Head(); ptr != linkedList.Sentinel(); ptr = ptr->next)
Append(ptr->datum);
}
return *this;
}
template <typename T>
void LinkedList<T>::InsertAfter(Node<T> const * arg, T const & item)
{
Node<T> * ptr = const_cast<Node<T>*> (arg);
if (NULL == ptr)
throw std::invalid_argument("invalid position");
Node<T> * const temp = new Node<T>(item, ptr->next);
ptr->next = temp;
if (tail == ptr)
tail = temp;
}
template <typename T>
void LinkedList<T>::InsertBefore(Node<T> const * arg, T const & item)
{
Node<T> * ptr = const_cast<Node<T>*> (arg);
if (NULL == ptr)
throw std::invalid_argument("invalid position");
Node<T> * const temp = new Node<T>(item, ptr);
if (head == ptr)
head = temp;
else
{
auto prevPtr = head;
while (prevPtr != &sentinel && prevPtr->next != ptr)
prevPtr = prevPtr->next;
if (prevPtr == &sentinel)
throw std::invalid_argument("invalid position");
prevPtr->next = temp;
}
}
} // namespace FoundationalDataStructure
#endif // LINKED_LIST_H
二、代码比较与分析
借助文本比较工具，对比上一篇（无sentinel）和本篇（有sentinel）的单链表实现代码。
1，类的声明
1）新增一个sentinel节点和一个访问接口；
2）head设计为指针的引用，同步操作；
2，构造和析构函数
1）head是sentinel节点的next指针的引用；
2）终端判断由NULL改为“&sentinel”。
3，复制和赋值函数
注意迭代结束条件
4，其他不同之处，主要是“终端判断由NULL改为“&sentinel””。
5，重点关注“Extract函数”的变化。它无需对头结点和其他节点分别处理。