双向链表的实现

#include<iostream>
using namespace std;

//节点

template <typename T>
struct node
{
    T value;
    node *prev;
    node *next;
    node(){};
    node(T t, node *prev, node *next){
        this->value = t;
        this->prev = prev;
        this->next = next;
    }
};

//链表

template<typename T>
class Link
{
public:
    Link();
    ~Link();

    int size();                                //输出总的长度
    bool is_empty();                            //判断是否为空

    T get(int index);                        //指定位置输出
    T get_first();                            //输出第一个元素
    T get_last();                            //输出最后一个元素

    void insert(int index, T t);                //按指定位置插入
    void insert_first(T t);                    //头插法
    void insert_last(T t);                    //尾插法

    T del(int index);                        //指定位置删除
    T delete_first();                        //删除头元素
    T delete_last();                        //删除最后一个元素

private:
    int count;        //元素的个数
    node<T> *head;
private:
    node<T>* get_node(int count);
};

template <typename T>
Link<T>::Link(){
    count = 0;
    //创建表头，没有数据
    head = new node<T>();
    head->prev = head->next = head;
}

//析构函数
template<typename T>
Link<T>::Link()
{
    //删除所有节点
    node<T> *temp;
    node<T> *p = head->next;
    while (p != head)
    {
        temp = p;
        p = p->next;
        delete temp;
    }
    //删除表头
    delete head;
    head = NULL;
}

//输出总的长度
template <typename T>
int Link<T>::size(){
    return count;
}

//返回链表是否为空
template <typename T>
bool Link<T>::is_empty()
{
    return count == 0;
}

//获取第index位置的节点
template <class T>
node<T>* Link<T>::get_node(int index){
    //判断参数有效性
    if (index < 0 || index >= count){
        throw:"index异常！";
        return NULL;
    }
    //正向查找
    if (inde <= count / 2){
        int i = 0;
        node<T>*p = head->next;
        while (i++ < index){
            p = p->next;
        }
        return p;
    }
    else{
        int i = 0, rindex=count-index-1;
        node<T> *p = head->prev;
        while (i++ < rindex){
            p = p->prev;
        }
        return p;
    }
}

//获取第index位置的节点的值
template<typename T>
T Link<T>::get(int index){
    return get_node(index)->value;
}

//获得最后一个节点的值
template<typename T>
T Link<T>::get_last()
{
    return get_node(count - 1)->value;
}

//将节点插入到第index位置之前
template <typename T>
void Link<T>::insert(int index, T t)
{
    if (index == 0) insert_first(t);
    node<T>*pindex = get_node(index);
    node<T>*p = new node<T>(t, pindex->prev, pindex);        //插入到index的前边，把index的前驱给它，index的地址为next
    pindex->prev->next = p;        pindex->prev = p;
    ++count;
}

//将节点插入第一个节点处
template<typename T>
void Link<T>::insert_first(T t)
{
    node<T>* p = new node<T>(t, head, head->next);
    head->next->prev = p;
    head->next = p;
}

//将节点追加到链表的末尾
template<typename T>
void Link<T>::insert_last(T t)
{
    node<T>*p = new node<T>(t, head->prev, head);
    head->prev->next = p;
    head->prev = p;
    ++count;
}

//删除index位置的节点
template<typename T>
T Link<T>::del(int index)
{
    node<T>*pindex = get_node(index);
    pindex->prev->next = pindex->next;
    pindex->next->prev = pindex->prev;
    T data = pindex->value;
    delete pindex;
    return data;
}

//删除第一个节点
template<typename T>
T Link<T>::delete_first(){
    retrun del(0);
}

//删除最后一个节点
template<typename T>
T Link<T>::delete_last()
{
    return del(count - 1);
}