用C++写的带模板双向链表

#ifndef _BLIST_H_
#define _BLIST_H_

#include <iostream>

using namespace std;

template<class T>
class List{

private:
    class Node{
    public:
        T data;
        Node * next;
        Node * prev;
        Node(const T & val=T())    :data(val),next(),prev(){}
        //在此节点后面添加节点new_node;
        void addNodeAfter( Node * new_node);
        //删除此节点后面一个节点,并释放占用内存
        void delNodeAfter();
    };
    
private:
    Node * head;
    Node * tail;
    size_t size_;

public:
    //分别为head,tail new 一个初始化的Node,并互相链接.
    List();
    
    /*read operation part
    *
    */
    //返回元素个数
    size_t size() const;
    //判断链表是否为空
    bool isEmpty() const;
    //读取链首元素的值,若没有元素，则返回head->data(后面以此处理);
    const T & getFirst() const;
    //读取链尾元素的值
    const T & getLast() const;
    //读取指定下标（1~size）处的值,若下标超出范围，则返回head->data
    const T & valueAt(size_t index) const;
    //依值返回节点
    Node * getNodeByVal(const T & item) const;
    //依值返回下标
    size_t getIndexByVal(const T & item) const;
    //依下标返回节点
    Node * getNodeByIndex(size_t index) const;
    //打印所有元素的值
    void showAll() const;
    
    /*write operation part
    *
    */
    //添加元素到链首
    void addFirst(const T & item);
    //添加元素到链尾
    void addLast(const T & item);
    //向指定下标处添加元素
    void addAt(size_t index, const T & item);
    //移除链首元素
    T removeFirst();
    //移除链尾元素
    T removeLast();
    //移除下标指定的元素
    T removeAt(size_t index);
    //移除同item等值的元素
    T removeVal(const T & item);
    //清理链表，释放内存。保留链首和链尾，以便再次使用.
    void clear();
    //销毁链表
    ~List();
};

template<class T>
//注意此处嵌套类的定义使用文法
void List<T>::Node::addNodeAfter(List<T>::Node * new_node)
{
    new_node->prev = this;
    new_node->next = next;
    next->prev = new_node;
    next = new_node;
}

template<class T>
void List<T>::Node::delNodeAfter()
{
    next->next->prev = this;
    delete next;
    next = next->next;
}

template<class T>
List<T>::List()
{
    head = new Node;
    tail = new Node;
    head->next = tail;
    tail->prev = head;
    size_ = 0;
}

template<class T>
size_t List<T>::size() const
{
    return size_;
}

template<class T>
bool List<T>::isEmpty() const
{
    return size_ == 0;
}

template<class T>
void List<T>::addFirst(const T & item)
{
    Node * new_node = new Node(item);
    head->addNodeAfter(new_node);
    ++size_;
}

template<class T>
void List<T>::addLast(const T & item)
{
    Node * new_node = new Node(item);
    tail->prev->addNodeAfter(new_node);
    ++size_;
}

template<class T>
void List<T>::addAt(size_t index, const T & item)
{
    if(index <= 1)
        addFirst(item);
    else if(index > size_)
        addLast(item);
    else
    {
        Node * new_node = new Node(item);
        Node * pos = getNodeByIndex(index);
        pos->prev->addNodeAfter(new_node);
        ++size_;
    }
}

template<class T>
const T & List<T>::getFirst() const
{
    return head->next->data;
}

template<class T>
const T & List<T>::getLast() const
{
    return tail->prev->data;
}

template<class T>
const T & List<T>::valueAt(size_t index) const
{
    Node * retNode = getNodeByIndex(index);
    if(retNode == NULL)
        return head->data;
    return retNode->data;
}

template<class T>
//返回嵌套类类型要用 typename 关键字注明类型,不然编译器报错
typename List<T>::Node * List<T>::getNodeByVal(const T & item) const
{
    Node * ret = head->next;
    while(ret != tail)
    {
        if(ret->data == item)
            return ret;
        ret = ret->next;
    }
    return NULL;
}

template<class T>
size_t List<T>::getIndexByVal(const T & item) const
{
    int ret = 0;
    Node * current = head->next;
    while(current != tail)
    {
        ++ret;
        if(current->data == item)
            return ret;
        current = current->next;
    }
    return 0;
}

template<class T>
typename List<T>::Node * List<T>::getNodeByIndex(size_t index) const
{
    if(index < 1 || index > size_)
        return NULL;
    Node * ret = head->next;
    for(int i = 1; i < index; i++)
        ret = ret->next;
    return ret;
}

template<class T>
T List<T>::removeFirst()
{
    if(isEmpty())
    {
        cout << "empty data!
";
        return T();
    }
    T ret = getFirst();
    head->delNodeAfter();
    --size_;
    return ret;
}

template<class T>
T List<T>::removeLast()
{
    if(isEmpty())
    {
        cout << "empty data!
";
        return T();
    }
    T ret = getLast();
    tail->prev->prev->delNodeAfter();
    --size_;
    return ret;
}

template<class T>
T List<T>::removeAt(size_t index)
{
    Node * del_node = getNodeByIndex(index);
    if(del_node == NULL)
        return head->data;
    T ret = del_node->data;
    del_node->prev->delNodeAfter();
    --size_;
    return ret;
}

template<class T>
T List<T>::removeVal(const T & item)
{
    Node * del_node = getNodeByVal(item);
    if(del_node == NULL)
        return head->data;
    T ret = del_node->data;
    del_node->prev->delNodeAfter();
    --size_;
    return ret;
}

template<class T>
void List<T>::showAll() const
{
    cout << "[";
    if(isEmpty())
    {
        cout << "]
";
        return;
    }
    Node * temp = head->next;
    while(temp != tail->prev)
    {
        cout << temp->data << ", ";
        temp = temp->next;
    }
    cout << temp->data << "]
";
}

template<class T>
void List<T>::clear()
{
    Node * del_node = NULL;
    Node * temp = head->next;
    while(temp != tail)
    {
        del_node = temp;
        temp = temp->next;
        delete del_node;
    }
    head->next = tail;
    tail->prev = head;
    size_ = 0;
}

template<class T>
List<T>::~List()
{
    clear();
    delete head;
    delete tail;
    head = tail = NULL;
}

#endif

#include "blist.h"

#include <iostream>
#include <string>
using namespace std;

int main()
{
    List<int> list;
    list.addFirst(10);
    list.addLast(20);
    list.addLast(30);
    list.addFirst(5);
    list.addAt(1,3);
    list.addAt(10,100);
    cout << "list.size() = " << list.size() << endl;
    cout << "getFirst = " << list.getFirst() << endl;
    cout << "getLast = " << list.getLast() << endl;
    for(int i = 0; i <= list.size() +1; i++)
        cout << "valueAt("<< i << ") = " << list.valueAt(i) << endl;
    cout << "getIndexByVal(30) = " << list.getIndexByVal(30) << endl;
    list.showAll();
    list.removeAt(4);
    cout << "After remove index 4
";
    list.showAll();
    list.removeVal(5);
    cout << "After remove value 5
";
    list.showAll();
    cout << "After clear
";
    list.clear();
    list.showAll();
    return 0;
}