单链表模板类

链表是最基本的数据结构，是一组不连续的数据的集合，链表中每个结点除包含结点元素外，还包含下一结点的地址。对链表可以实现插入、删除、查找以及显示等操作。

/*
 * 单链表模板类List.h
 */ 
#ifndef _LIST_H_
#define _LIST_H_

#include <iostream>
using namespace std;

template <class TYPE>
class List
{
public:
    List();
    List(TYPE x[], int n);
    List(const List<TYPE> *l);
    ~List();
    void insert(const TYPE &x);
    bool remove(const TYPE &x);
    void display() const;
    int size() const;
    int at(int x, TYPE &k) const;
private:
    struct ListNode
    {
        TYPE data;
        ListNode *next;
    };
    ListNode *list;
    void insert(ListNode *&l, const TYPE &x);
    bool remove(ListNode *&l, const TYPE &x);
    void display(ListNode *l) const;
    int size(ListNode *l) const;
    int at(ListNode *l, int x, TYPE &k) const;
};

#endif

// 构造函数
template <class TYPE>
List<TYPE>::List()
{
    list = new ListNode;
    list->next = NULL;
}

// 利用数组初始化链表
template <class TYPE>
List<TYPE>::List(TYPE x[], int n)
{
    list = new ListNode;
    list->next = NULL;
    for(int i = 0; i < n; ++i)
    {
        insert(list, x[i]);
    }
}

// 利用链表初始化链表
template <class TYPE>
List<TYPE>::List(const List<TYPE> *l)
{
    if(l->list == NULL)
        list = NULL;
    else
    {
        ListNode *p = l->list->next;
        ListNode *pt = list = new ListNode;
        while(p)
        {
            ListNode *q = new ListNode;
            q->data = p->data;
            q->next = NULL;
            pt->next = q;
            pt = q;
            p = p->next;
        }
    }
}

// 析构函数
template <class TYPE>
List<TYPE>::~List()
{
    List *p = list->next;
    while(p)
    {
        list->next = p->next;
        free(p);
        p = list->next;
    }
}

// 外部调用插入数据方法
template <class TYPE>
void List<TYPE>::insert(const TYPE &x)
{
    insert(list, x);
}

// 内部调用向List插入数据
template <class TYPE>
void List<TYPE>::insert(ListNode *&l, const TYPE &x)
{
    ListNode *node = new ListNode;
    node->data = x;
    node->next = l->next;
    l->next = node;
}

// 删除值为x的，删除成功返回true，失败返回false
template <class TYPE>
bool List<TYPE>::remove(const TYPE &x)
{
    remove(list, x);
}

template <class TYPE>
bool List<TYPE>::remove(ListNode *&l, const TYPE &x)
{
    if(l == NULL)
        return false;

    ListNode *p = l->next;
    ListNode *pre = l;
    while(p && p->data != x)
    {
        pre = p;
        p = p->next;
    }
    if(p)
    {
        pre->next = p->next;
        delete p;
    }
    return true;
}

// 打印链表元素
template <class TYPE>
void List<TYPE>::display() const
{
    display(list);
}

template <class TYPE>
void List<TYPE>::display(ListNode *l) const
{
    if(l != NULL)
    {
        ListNode *p = l->next;
        if(p == NULL)
        {
            cout << "链表为空！" << endl;
            return;
        }
        while(p)
        {
            cout << p->data << " ";
            p = p->next;
        }
    }
    else
        cout << "链表不存在！" << endl;
}

// 返回链表中元素个数
template <class TYPE>
int List<TYPE>::size() const
{
    size(list);
}

template <class TYPE>
int List<TYPE>::size(ListNode *l) const
{
    int s = 0;
    if(l != NULL)
    {
        ListNode *p = l->next;
        while(p)
        {
            s++;
            p = p->next;
        }
    }
    return s;
}

/*
 * 根据索引值取链表中的元素
 * 如果索引值大于链表的大小返回-1
 * 否则将索引值处结点的值保存在k中并返回1
 */
template <class TYPE>
int List<TYPE>::at(int x, TYPE &k) const
{
    return at(list, x, k);
}

template <class TYPE>
int List<TYPE>::at(ListNode *l, int x, TYPE &k) const
{
    if(size(l) < x || x <= 0)
    {
        return -1;
    }
    else
    {
        int i = 0;
        ListNode *p = l->next;
        while(p && i < x)
        {
            p = p->next;
            i++;
        }
        k = p->data;
    }
    return 1;
}