c++ 链表（模板）简单实现

/*模板*/

#include <iostream>
using namespace std;

template<class T>
struct Node
{
	T data;
	Node<T> *next;

	Node()
	{
		next=NULL;
	}
	Node(T element)
	{
		this->data=element;
		next=NULL;
	}
};

template<class T>
class List
{
public:
	List();

	//链表头添加数据
	void addFirst(T data);

	//链表尾添加数据
	void addLast(T data);

	//得到链表头元素
	T getFirst();

	//得到链表尾元素
	T getLast();

	//删除链表头元素并返回值
	T removeFirt();
	T removeLast();

	//指定位置插入元素
	void addPos(size_t index,T data);

	//清空链表
	void clear();

	//返回链表指定下标元素
	T get(size_t index);

	//返回链表中第一个匹配元素的结点下标
	size_t indexOf(T data);

	bool isEmpty();

	//删除指定元素（链表中的第一个）
	void remove(T data);

	//删除指定位置元素
	T removeAt(size_t index);

	size_t getSize();

private:
	Node<T> *head,*tail;
	size_t size;
};

template<class T>
List<T>::List()
{
	head=tail=NULL;
	size=0;
}

template<class T>
void List<T>::addFirst(T data)
{
	Node<T> *newNode=new Node<T>(data);
	newNode->next=head;
	head=newNode;
	size++;
	if(tail==NULL)
	{
		tail=head;
	}
}

template<class T>
void List<T>::addLast(T data)
{
	if(tail==NULL)
	{
		head=tail=new Node<T>(data);
	}
	else
	{
		tail->next=new Node<T>(data);
		tail=tail->next;
	}
	size++;
}

template<class T>
T List<T>::getFirst() throw(runtime_error)
{
	if(size==0)
	{
		throw runtime_error("Index out of rangge");
	}
	else
	{
		return head->data;
	}
}

template<class T>
T List<T>::getLast() throw (runtime_error)
{
	if(size==0)
	{
		throw runtime_error("Index out of range");
	}
	else
	{
		return tail->data;
	}
}

template<class T>
T List<T>::removeFirt() throw (runtime_error)
{
	if(size==0)
	{
		throw runtime_error("No element in the list");
	}
	else
	{
		Node<T> *temp=head;
		head=head->next;
		if(head==NULL)
		{
			tail=NULL;
		}
		size--;
		T data=temp->data;
		delete temp;
		return data;
	}
}

template<class T>
T List<T>::removeLast() throw(runtime_error)
{
	if(size==0)
	{
		throw runtime_error("No elements in the list");
	}
	else if(size==1)
	{
		Node<T> *temp=head;
		head=tail=NULL;
		size=0;
		T data=temp->data;
		delete temp;
		return data;
	}
	else
	{
		Node<T> *current=head;
		for(size_t i=0;i<size-2;i++)
		{
			current=current->next;
		}
		Node<T> *temp=tail;
		tail=current;
		tail->next=NULL;
		size--;
		T data=temp->data;
		delete temp;
		return data;
	}
}

template<class T>
T List<T>::removeAt(size_t index)
{
	if(index<0 || index>=size)
	{
		throw runtime_error("Index out of range");
	}
	else if(index==0)
	{
		return removeFirt();
	}
	else if(index==size-1)
	{
		return removeLast();
	}
	else
	{
		Node<T> *previous=head;
		for(size_t i=1;i<index;i++)
		{
			previous=previous->next;
		}
		Node<T> *current=previous->next;
		previous->next=current->next;
		size--;
		T data=current->data;
		delete current;
		return data;
	}
}

template<class T>
void List<T>::addPos(size_t index,T data)
{
	if(index==0)
	{
		addFirst(data);
	}
	else if(index>=size)
	{
		addLast(data);
	}
	else
	{
		Node<T> *current=head;
		for(size_t i=0;i<index;i++)
		{
			current=current->next;
		}
		Node<T> *temp=current->next;
		current->next=new Node<T>(data);
		(current->next)->next=temp;
		size++;
	}
}

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

template<class T>
T List<T>::get(size_t index)
{
	if(index<0 || index>size-1)
	{
		throw runtime_error("Index out of range");
	}

	Node<T> *current=head;
	for(size_t i=0;i<index;i++)
	{
		current=current->next;
	}
	return current->data;
}

template<class T>
size_t List<T>::indexOf(T data)
{
	Node<T> *current=head;

	for(size_t i=0;i<size;i++)
	{
		if(current->data=data)
		{
			return i;
		}
		current=current->next;
	}
	return -1;
}

template<class T>
bool List<T>::isEmpty()
{
	return head==NULL;
}

template<class T>
void List<T>::remove(T element)
{
	Node<T> *current=head;

	for(size_t i=0;i<size;i++)
	{
		if(current->data==element)
		{
			if(i==0)
			{
				removeFirt();
			}
			else if(i==size-1)
			{
				removeLast();
			}
			else
			{
				removeAt(i);
			}
			break;
		}
		current=current->next;
	}
}

template<class T>
size_t List<T>::getSize()
{
	return size;
}
int main()
{
    /*别忘了捕获异常*/
    try
    {

    List<int> list;

    }
    catch(exception e)
    {
        cout<<e.what()<<endl;
    }

    cout<<endl;
    system("pause");
    return 0;
}