线性表链接实现--双循环链表

                    在实现时没有引入两个辅助节点，所以实现时需要考虑特殊情况，比如头和尾插入删除操作时，需要改变指向头和尾的指针。在做迭代器的时候还有麻烦，遍历链表时需要借助量表的长度，不然不能标识结束，我想到的办法是在迭代器中做一些记录工作，比如当前的下标和整个链表的长度。有解决办法的希望指教。

                   

#ifndef LINKLIST_H
#define LINKLIST_H
#include "list.hpp"

template <typename T>
struct node {
    T d;
    node *pre, *next;
    node(const T& _d, node *_pre = NULL, node *_next = NULL):
        d(_d),
        pre(_pre),
        next(_next) {

    }
};


template <typename T>
class LinkList : public List<T>
{
public:
    /**
     * @brief The Iterator class 双循环链表设计时没有头和尾节点，所以在设计迭代器时不方便，比如遍历链表必须借助链表的长度
     */
    class Iterator
    {
        friend std::ostream& operator << (std::ostream &os, const Iterator &obj) {
            os << obj.p->d;
            return os;
        }
    public:
        Iterator(node<T> *_p):p(_p){}
        ~Iterator(){}
        Iterator(const Iterator& obj):p(obj.p){}
        Iterator& operator = (const Iterator& obj) {
            p = obj.p;
            return *this;
        }

        Iterator& operator ++() {
            p = p->next;
            return *this;
        }
        Iterator operator ++(int) {
            Iterator t(p);
            p = p->next;
            return  t;
        }
        Iterator& operator -- (){
            p = p->pre;
            return *this;
        }
        Iterator operator -- (int) {
            Iterator t(p);
            p = p->pre;
            return  t;
        }
        T operator * () {
            return p->d;
        }
        T* operator -> () {
            return &p->d;
        }

        bool operator == (const Iterator &ite) {
            return p == ite.p;
        }

        bool operator != (const Iterator &ite) {
            return p != ite.p;
        }
    private:
        node<T> *p;
    };
    LinkList():head(NULL),tail(NULL),size(0) {}
    ~LinkList();
    void clear();
    int length() const;
    /**
     * @brief insert 插入到链表的指定位置 插入i的下个位置
     * @param i 下标 从0开始
     * @param t
     */
    void insert(int i, const T &t);
    int search(const T &t) const;
    T visit(int i) const;
    void traverse(std::ostream &os = std::cout) const;
    void remove(int i);
    void add(const T& o);
    void push_front(const T& o);
    void push_tail(const T& o);
    T pop_front();
    T pop_tail();
    Iterator begin() const {
        return Iterator(head);
    }
private:
    node<T> *head, *tail;
    int size;
    node<T>* local(int i) const;
};

template <typename T>
LinkList<T>::~LinkList()
{
    clear();
}

template <typename T>
/**
 * @brief LinkList<T>::add 在双循环链表的tail添加节点
 * @param o
 */
void LinkList<T>::add(const T &o)
{
    node<T> *p = NULL;
    if (size == 0) {
        p = new node<T>(o);
        head = tail = p;
        head->pre = tail;
        tail->next = head;
    } else {
        p = new node<T>(o,tail,head);
        head->pre = p;
        tail->next = p;
        tail = p;
    }
    ++size;
}


template <typename T>
node<T> *LinkList<T>::local(int i) const
{
    if (i < 0 ||i > size - 1) throw BadValue();
    node<T> *p = head;
    for (int j = 0;j < i;++j) {
        p = p->next;
    }
    return p;
}


template <typename T>
/**
 * @brief LinkList<T>::clear 只有一个节点
 */
void LinkList<T>::clear()
{
    node<T> *p = head;
    while(size--) {
        head = head->next;
        delete p;
        p = head;
    }
    head = tail = NULL;
    size = 0;
}

template <typename T>
/**
 * @brief LinkList<T>::insert 插在i的后面
 * @param i
 * @param t
 */
void LinkList<T>::insert(int i, const T &t)
{
    if ((size == 0 && i == 0) || size-1 == i) {//过滤掉空链表插入和尾部插入
        add(t);
    } else {
        node<T> *p = local(i);//i节点
        node<T> *n = p->next;//下个节点
        node<T> *d = new node<T>(t,p,n);
        p->next = d;
        n->pre = d;
        ++size;
    }

}

template <typename T>
int LinkList<T>::length() const
{
    return size;
}

template <typename T>
int LinkList<T>::search(const T &t) const
{
    int re = -1;
    node<T> *p = head;
    for (int i = 0;i < size;++i) {
        if (p->d == t) {
            re = i;
            break;
        }
        p = p->next;
    }
    return re;
}

template <typename T>
T LinkList<T>::visit(int i) const
{
    return local(i)->d;
}
template <typename T>
void LinkList<T>::remove(int i)
{
    node<T> *p = local(i);
    p->pre->next = p->next;
    p->next->pre = p->pre;
    --size;
    if (i == 0) {
        head = p->next;
        tail->next = head;
    }
    if (i == size-1) {
        tail = p->pre;
        head->pre = tail;
    }
    delete p;
}

template <typename T>
void LinkList<T>::traverse(std::ostream &os) const
{
    node<T> *p = head;
    for (int i = 0;i < size;++i) {
        os << p->d << "    ";
        p = p->next;
    }

}

template <typename T>
/**
 * @brief LinkList<T>::push_front 插入头部
 * @param o
 */
void LinkList<T>::push_front(const T &o)
{
    node<T> *p = new node<T>(o,tail,head);
    p->next =head;
    p->pre = tail;
    head = p;
    ++size;

}
template <typename T>
void LinkList<T>::push_tail(const T &o)
{
    add(o);
}

template <typename T>
T LinkList<T>::pop_front()
{
    T t = local(0)->d;
    remove(0);
    return t;
}
template <typename T>
T LinkList<T>::pop_tail()
{
    T t = local(size-1)->d;
    remove(size-1);
    return t;
}


#endif