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

        本篇主要介绍一种重要的链表——“双向链表”（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(); }”的声明和定义格式，以及类模版前缀的添加方式。