List基本模板

头文件LinkedList.h

//LinkedList.h
#include<iostream>
#ifndef LINKEDLIST_H_INCLUDED
#define LINKEDLIST_H_INCLUDED

#endif // LINKEDLIST_H_INCLUDED

using namespace std;

//const int NULL=0;

template <class Type> struct LinkNode
{
public:
    Type data;
    LinkNode<Type> *link;  //这里不声明type也能通过吧

    LinkNode(LinkNode<Type> *ptr=NULL)
    {
        link=ptr;
    }
    LinkNode(const Type& item,LinkNode<Type> *ptr=NULL)  //注意第二个形参的const可否存在
    {
        data=item;
        link=ptr;   //link是一个非const指针
    }
};




template <class Type> class List
{
public:
    List()
    {
        first=new LinkNode<Type>;
    }
    List(const Type& x)
    {
        first=new LinkNode<Type>(x);
    }

    List(List<Type> &L);

    ~List()
    {
        makeEmpty();
    }

    void makeEmpty();
    int Length() const;
    LinkNode<Type>* getHead() const
    {
        return first;
    }
    LinkNode<Type>* search(Type x);
    LinkNode<Type>* locate(int i);

    bool getData(int i,Type& x);//将x值置为位置为i的数据元素值
    void setData(int i,Type& x);//将位置i的数据元素置为x

    bool insert(int i,const Type& x);
    bool remove(int i,Type& x);

    bool isEmpty() const
    {
        return first->link==NULL?true:false;
    }
    bool isFull() const
    {
        return false;
    }

    void sort();
    void input();
    void output();

    void inputFront(Type endtag);
    void inputRear(Type endtag);
    List<Type>& operator=(List<Type>& L);

protected:
    LinkNode<Type>* first;
};





template<class Type> List<Type>::List(List<Type>& L)
{
    Type value;
    LinkNode<Type> *srcptr=L.getHead();
    LinkNode<Type> *destptr=first=new LinkNode<Type>;
    while(srcptr->link!=NULL)
    {
        value=srcptr->link->data;
        destptr->link=new LinkNode<Type>(value);
        destptr=destptr->link;
        srcptr=srcptr->link;
    }
    destptr->link=NULL;
}

template<class Type> void List<Type>::makeEmpty()
{
    LinkNode<Type> *q;
    while(first->link!=NULL)
    {
        q=first->link;
        first->link=q->link;
        delete q;
    }
}

template<class Type> int List<Type>::Length() const
{
    int count=0;
    LinkNode<Type> *q=first->link;
    while(q!=NULL)
    {
        q=q->link;
        count++;
    }
    return count;
}

template<class Type> LinkNode<Type>* List<Type>::search(Type x)
{
    LinkNode<Type> *current=first->link;
    while(current!=NULL)                //写的有技巧
        if(current->data==x) break;
        else current=current->link;
    return current;
}

template<class Type> LinkNode<Type>* List<Type>::locate(int i)
{
    if(i<0) return NULL;
    LinkNode<Type> *current=first;
    int k=0;
    while(current!=NULL&&k<i)
    {
        current=current->link;
        k++;
    }
    return current;
}

template<class Type> bool List<Type>::getData(int i,Type& x)
{
    if(i<0)
        return false;
    LinkNode<Type> *current=locate(i);
    if(current==NULL)
        return false;
    else
    {
        x=current->data;
        return true;
    }
}

template<class Type> void List<Type>::setData(int i,Type& x)
{
    if(i<=0)
        return ;
    LinkNode<Type> *current=locate(i);
    if(current==NULL)
        return ;
    else current->data=x;
}

template<class Type> bool List<Type>::insert(int i,const Type& x)
{
    LinkNode<Type> *current=locate(i);
    if(current==NULL)
        return false;
    LinkNode<Type> *newNode=new LinkNode<Type>(x);
    if(newNode==NULL)
    {
        cerr<<"存储分配错误！"<<endl;
        return false;
    }
    newNode->link=current->link;
    current->link=newNode;
    return true;
}

template<class Type> bool List<Type>::remove(int i,Type& x)
{
    LinkNode<Type> *current=locate(i-1);
    if(current==NULL||current->link==NULL)
        return false;
    LinkNode<Type> *del=current->link;
    current->link=del->link;
    x=del->data;
    delete del;
    return true;
}

template<class Type> void List<Type>::output()
{
    LinkNode<Type> *current=first->link;
    while(current!=NULL)
    {
        cout<<current->data<<endl;
        current=current->link;
    }
}

template<class Type> List<Type>& List<Type>::operator=(List<Type>& L)
{
    Type value;
    LinkNode<Type> *srcptr=L.getHead();
    LinkNode<Type> *destptr=first=new LinkNode<Type>;
    while(srcptr->link!=NULL)
    {
        value=srcptr->link->data;
        destptr->link=new LinkNode<Type>(value);
        destptr=destptr->link;
        srcptr=srcptr->link;
    }
    destptr->link=NULL;
    return *this;
}

template<class Type> void List<Type>::inputFront(Type endtag)
{
    LinkNode<Type> *newNode;
    Type val;
    makeEmpty();
    cin>>val;
    while(val!=endtag)
    {
        newNode=new LinkNode<Type>(val);
        if(newNode==NULL)
        {
            cerr<<"输入时存储分配错误！"<<endl;
            return false;
        }
        newNode->link=first->link;
        first->link=newNode;
        cin>>val;
    }
}

template<class Type> void List<Type>::inputRear(Type endtag)
{
    LinkNode<Type> *newNode,*last;
    Type val;
    makeEmpty();
    cin>>val;
    last=first;
    while(val!=endtag)
    {
        newNode=new LinkNode<Type>(val);
        if(newNode==NULL)
        {
            cerr<<"输入存储分配错误！"<<endl;
            return ;
        }
        last->link=newNode;
        last=newNode;
        cin>>val;
    }
}

TestList.cpp

//TestList.cpp
#include<iostream>
#include"LinkedList.h"

using namespace std;

int main()
{
    List<string> list;
    list.inputRear("a");
    list.insert(2,"abc");
    string b;
    list.remove(10,b);
    list.output();
    return 0;
}