十五、双向链表的实现

单链表的每个结点增加一个指针域，用于指向结点的前驱

单链表的另一个缺陷：

• 单向性：只能从头结点开始高效访问链表中的数据元素
• 缺陷：如果需要逆向访问单链表中的数据元素将及其低效

int main()
{
	LinkList<int> l;
    for(int i = 0; i < 5; i++)	// O(n)
    {
        l.insert(0, i);	// 时间复杂度为O(1)，往单链表0结点插入元素，耗时为常数
    }
    
    // 逆向遍历的时候，非常低效
    for(int i = l.length()-1; i >=0; i--)	// O(n^2)
    {
        cout << l.get(i) << endl;
    }
}

新的线性表，设计思路：

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

好处：不管游标目前为与哪个位置上，都可以通过next指针访问后继结点，通过pre指针访问前驱结点。

双向链表的继承层次结构

因为双向链表在内部的实现上与单链表有较大差异，所以将其与单链表放在了同级，而不是单链表的子类。用单链表的地方可以完全用双向链表来代替。

DualLinkList的实现

#ifndef DUALLINKLIST_H
#define DUALLINKLIST_H


namespace DTLib
{

template <typename T>
class DualLinkList : public List<T>
{
protected:
    struct Node : public Object
    {
        T value;    // 数据域
        Node* next; // 指针域
        Node* pre;
    };

    // 头结点，是不是弄成指针更方便点儿
    // mutable Node m_header;
    // 创建m_header时，会调用T value，用泛指类型创建头结点的数据域，当泛指类型为用户自定义类型时，用用户自定义的类类型在库中创建对象，就有可能出错了，而且在外部看来，并没有用该类型创建对象，问题定位很麻烦
    // 解决办法：构造头结点时，不调用泛指类型创建头结点，而是按内存分布自己重新构造
    // 在内存布局上和之前没有差异，差异在于不管泛指类型是什么，都不会去调用泛指类型的构造函数了
    // 虽然内存布局上是一样的，但是是个空类型，不能直接用，要进行类型转换
    // 同样要继承于Object
    mutable struct : public Object
    {
        char reserved[sizeof(T)];   // 没实际作用，占空间
        Node* next;
        Node* pre;
    } m_header;

    int m_length;   // 记录链表长度

    int m_step;
    Node* m_current;


    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* create()
    {
        return new Node();
    }
    virtual void destory(Node* pn)
    {
        delete pn;
    }

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


    bool insert(const T& e)
    {
        return insert(m_length, e);
    }
    bool insert(int i, const T& e)  // O(n)
    {
        // 注意i的范围
        bool ret = ((i>=0) && (i<=m_length));
        if (ret)
        {
           // Node* node = new Node();
            Node* node = create();   // 这里的create动态决定，是虚函数，根据Node对象的类型来决定
            if (node != NULL)
            {
                // current的目标指向其实都是目标位置的前一个，比如：在第0个位置增加元素，current指向的是header
                Node* current = position(i);
                Node* next = current->next;

                node->value = e;

                node->next = next;
                current->next = node;
                // 注意current是不是头结点
                if(current != reinterpret_cast<Node*>(&m_header))
                {
                    node->pre = current;
                }
                else
                {
                    node->pre = NULL;
                }

                if(next != NULL)
                {// 在最后插入
                    next->pre = node;
                }

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

        return ret;
    }

    bool remove(int i)      // O(n)
    {
        // 注意i的范围
        bool ret = ((i>=0) && (i<m_length));
        if (ret)
        {
            Node* current = position(i);
            Node* toDel = current->next;
            Node* next = toDel->next;

            if(m_current == toDel)
            {
                m_current = next;
            }

            current->next = next;
            if(next !=  NULL)
            {
                next->pre = toDel->pre;
            }

            m_length--;

            destory(toDel);
        }
        return ret;
    }

    bool set(int i, const T& e) // O(n)
    {
        // 注意i的范围
        bool ret = ((i>=0) && (i<m_length));
        if (ret)
        {
            // Node* current = position(i);
            position(i)->next->value = e;
        }

        return ret;
    }

    // get函数用起来不方便，重载一下
    virtual T get(int i) const  // O(n)
    {
        T ret;
        if (get(i, ret))
        {
            return ret;
        }
        else
        {
            THROW_EXCEPTION(IndexOutOfBoundsException, "Invalid parameter i to get element...");
        }
    }

    bool get(int i, T& e) const // O(n)
    {
        bool ret = ((i>=0) && (i<m_length));
        if (ret)
        {
            // Node* current = position(i);
            e = position(i)->next->value;
            // get是const成员函数，按理来说不能修改成员变量的值，Node* current=&m_header，会被误认为要更改成员变量的值，故报错
            // 解决方案是对m_header加上mutable，开一个例外
        }

        return ret;
    }

    int find(const T& e) const // O(n)
    {
        int ret = -1;
        int i = 0;
        Node* node = m_header.next;
        while(node)
        {
            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);
        }

    }

    // 遍历操作
    // i 目标位置，step 游标每次移动结点的数目
    virtual bool move(int i, int step = 1)  // O(n)
    {
        bool ret = ((i >= 0) && (i < m_length) && (step > 0));
        if(ret)
        {
            // 将游标定位到目标位置i的地方
            m_current = position(i)->next;
            m_step = step;
        }

        return ret;
    }

    virtual bool end()
    {
        return (m_current == NULL);
    }

    virtual T current()
    {
        // 返回游标指向的位置的元素值
        //if(m_current != NULL)
        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++;
        }

        // i的值和m_step的值是一样的，就表示移动成功
        return (i == m_step);
    }

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

        // i的值和m_step的值是一样的，就表示移动成功
        return (i == m_step);
    }


    ~DualLinkList() // O(n)
    {
        clear();
    }
};


}

#endif // DUALLINKLIST_H


// main.c
#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^2)
    {
        cout << dl.get(i) << endl;
    }

    for(dl.move(0); !dl.end(); dl.next())    // O(n)
    {
        cout << dl.current() << endl;
    }
    
    cout << "begin" << endl;

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

    // 删除5数据元素
    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;
    for(dl.move(dl.length()-1); !dl.end(); dl.pre())    // O(n)
    {
        cout << dl.current() << endl;
    }
	return 0;
}

小结

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

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

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

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