线性表的链式存储——双向链表的实现

1，单链表另一个缺陷：

       1，单向性：

              1，只能从头结点开始高效访问链表中的数据元素；

       2，缺陷：

              1，如果需要逆向访问（最先访问倒数第一个节点）单链表中的数据元素将极其低效；

              2，插入时效率很高，逆序访问时效率很低：

                    

                    

2，新的线性表（解决高效访问问题）：

       1，设计思路：

              1，在单链表的结点中增加一个指针 pre，用于指向当前结点的前驱结点：

  

             

3，双向链表的继承层次结构：

 

       1，双向链表和单链表在内部的实现上是完全不同的，所以它们不应该是父子关系，应该是同级别兄弟关系；

      

4，DualLinkList 的定义：

      

      

5，插入新结点：

      

6，删除结点：

  

7，DualLinkList 双向链表的实现：

#ifndef DUALLINKLIST_H
#define DUALLINKLIST_H

#include "List.h"
#include "Exception.h"

/* 双向链表三要素：长度、头结点、前后指针域。 */
/* 双向静态链表和双向循环链表 */
namespace DTLib
{

template <typename T>
class DualLinkList : public List<T>
{
protected:
    struct Node : public Object   
    {
        T value;
        Node* next;
        Node* pre;
　　 };

    mutable struct : public Object   // 构造头结点的时候，设法不去调用泛指类型的函数；构造匿名类型的结构
    {
        char reserved[sizeof(T)];   // 定义数组，没有实际作用，仅仅用于占空间
        Node* next;
        Node* pre;
　　 }m_header;    //  头结点对象在内存布局上面和上面结构Node结构体没有任何差异，有差异仅在于不管T为何对象，都不会调用T的构造函数（如果有）

    int m_length;      // 定义链表的长度
    Node* m_current;     // 定义遍历函数当前游标的位置
　　 int m_step;    // 定义遍历函数遍历的步幅

    Node* position(int i) const    // O(n)
    {
        Node* ret = reinterpret_cast<Node*>(&m_header);

        for(int p=0; p<i; p++)
        {
            ret = ret->next;
        }

        return ret;
　　 }

    virtual Node* creat()
    {
        return new Node();
　　 }

    virtual void destroy(Node* pn)
    {
        delete pn;   // 只能对堆空间来释放空间，如果不是堆空间，则程序会不稳定；
　　 }

public:
    DualLinkList()                                       
    {
        m_header.pre = NULL;
        m_header.next = NULL;
        m_length = 0;
        m_current = NULL;
        m_step = 1;
　　 }

    bool insert(const T& e)   // 在线性表的尾部默认的插入一个元素，所以 i 省略了；
    {
        return insert(m_length, e);
　　 }

    bool insert(int i, const T& e)    //(n)   
    {
        bool ret = ( (0 <= i) && (i <= m_length));
        if( ret )
        {
            Node* node = creat();  // 从堆空间申请一个对象出来；取决于调用的是哪个具体的对象，因为为虚函数；
            if( node != NULL )
            {
                Node* current = position(i);  // O(n)
                Node* next = current->next;
                node->value = e;
                node->next = next;   // 第一步
                current->next = node;// 第二步    赋值时是节点，比较的时候是地址

                /* 后向插入中由于头结点为空，已经自然的考虑了插入尾结点和首结点，而这里需要重新考虑 */
                if( current != reinterpret_cast<Node*>(&m_header) ) // 第三步多的，为头结点则插入的是第 0 个结点，涉及 pre 则判断
                {
                    node->pre = current;
                }
                else
                {
                    node->pre = NULL;
                }

                if( next != NULL )  // 第四步 多的，向后插入已经考虑了最后的 NULL；
                {
                    next->pre = node;
                }

                m_length++;
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to insert new element ...");
            }
        }

        return ret;
109　　  }

    bool remove(int i)     // O(n)  
    {
        bool ret = ( (0 <= i) && (i < m_length) );

        if( ret )
        {
            Node* current = position(i);   // O(n)
            Node* toDel = current->next;                            
            Node* next = toDel->next;

            if( m_current == toDel)  // 第零步
            {
                m_current = toDel->next;
            }

            current->next = next;  // 第一步

            if( next != NULL // 第二步，多了此步,不要忘记判断了，涉及 pre 则判断
            {
                next->pre = toDel->pre;
            }

            m_length--;
            destroy(toDel);
        }

        return ret;
　　 }

    bool set(int i, const T& e)
    {
        bool ret = ( (0 <= i) && (i < m_length) );

        if( ret )
        {
            position(i)->next->value = e;     // O(n)
        }

        return ret;
　　 }

    virtual T get(int i) const
    {
        T ret;

        if( get(i, ret) )
        {
            return ret;
        }
        else
        {
            THROW_EXCEPTION(IndexOutOfBoundsException, "Invalid parameter i to get element ...");
        }

        return ret;
　　 }

    bool get(int i, T& e) const     //  const 表明不能够修改任何成员变量的值；
    {
        bool ret = ( (0 <= i) && (i <= m_length) );

        if( ret )
        {
            e = position(i)->next->value;    // O(n)
        }

        return ret;
　　 }

    int find(const T& e) const   // 发现当前值为 e 的节点所处的链表位置 i ；
    {
        int ret = -1;
        int i = 0;
        Node* node = m_header.next;

        while( node )   // O(n)
        {
            if(node->value == e)
            {
                ret = i;
                break;
            }
            else
            {
                node = node->next;
                i++;
            }
        }

        return ret;
　　 }

    int length() const   // O(1)
    {
        return m_length;
　　 }

    void clear()   // O(n)  
    {
        while( m_length > 0 )
        {
            remove(0);
        }
　　 }

    /* 以下四个函数move()，end()，next()，current()是为了将遍历输出函数时间复杂度由O(n*n)降为O(n) */
    virtual bool move(int i, int step = 1)    // 从第 i 个位置移动，每次移//动 1 个位置； O(n)
    {
        bool ret = ( (0<= i) && (i<m_length) && (0<step));

        if( ret )
        {
            m_current = position(i)->next;   // 定位到节点i，不是第i个节点，所以要加上next
            m_step = step;   // 将每次要移动的值传进来
        }

        return ret;
　　 }

    virtual bool end()  // 判断当前的游标是否结束
    {
        return (m_current == NULL);  // 这里不可写成赋值了
　　 }

    virtual T current()   // 获取游标当前位置的值
    {
        if( !end() )
        {
            return m_current->value;
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No value at current position ...");
        }
　　 }

    virtual bool next()   // 移动游标
    {
        int i = 0;

        while( (i<m_step) && (!end()) )
        {
                m_current = m_current->next;
                i++;
        }

        return (i == m_step);
　　 }

    virtual bool pre()  // 移动游标  新添加
    {
        int i = 0;

        while( (i<m_step) && (!end()) )
        {
                m_current = m_current->pre;
                i++;
        }

        return (i == m_step);
271　　  }

    ~DualLinkList()    // O(n)
    {
        clear();  // 构造函数和析构函数中不会发生多态；不管是直接调用的虚函数，还是间接调用的虚函数，都是直接调用的当前类中的实现版本；
    }
};

}

#endif // DUALLINKLIST_H

8，DualLinkList 实现的测试代码：

#include <iostream>
#include "DualLinkList.h"

using namespace std;
using namespace DTLib;

int main()
{
DualLinkList<int> dl;

    for(int i=0; i<5; i++)
    {
        dl.insert(0, i);
        dl.insert(0, 5);
　　 }

    for(int i=0; i<dl.length(); i++)      // O(n*n)
    {
        cout << dl.get(i)  << endl;
　　 }

　　 cout << "begin" << endl;
　　 dl.move(dl.length()-1);

    while( !dl.end() )
    {
        if( dl.current() == 5 )
        {
            cout << dl.current() << endl;
            dl.remove(dl.find(dl.current()));
        }
        else
        {
            dl.pre();
        }
　　 }
　　 cout << "end" << endl;

    cout << "begin" << endl;
    for(dl.move(dl.length()-1); !dl.end(); dl.pre())     // O(n)
    {
        cout << dl.current() << endl;
    }
　　 cout << "end" << endl;

    return 0;
}

9，小结：

       1，双向链表是为了弥补单链表的缺陷而重新设计的；

       2，在概念上，双向链表不是单链表，没有继承关系；

       3，双向链表中的游标能够直接访问当前结点的前驱和后继；

       4，双向链表是线性表概念的最终实现（更贴近理论上的线性表）；