类模板与链表

#include<iostream>
using namespace std;
template<class T> struct ListNode//相当于把类或结构体当成type<T>类型的
{
    T data;
    ListNode<T> *next;
};
template<class T>
class List
{
public:
        List();
        ~List();
        bool insertNode(T,int);//在链表指定位置插入元素
        void deleteNode(int n);//删除链表指定元素
        int find(T t);//查找指定元素在链表中的位置
        void empty();//清除链表所有元素
        bool print();//打印链表
        int getLenth()//获取链表长度
        {
            return length;
        }
private:
        ListNode<T> *first,*last;
        int length;
};
template<class T>//模板声明
void List<T>::empty()
{
    ListNode<T> *p,*q;
    p=first->next;
    first->next=NULL;//清除第一个链表的数据
    while(p!=NULL)
    {
        q=p;
        p=p->next;
        delete q;
    }
   length=0;
}
template<class T>
bool List<T>::insertNode(T t,int n)
{
    ListNode<T> *p;
    p=first;
    int i=1;
    while(p!=NULL&&i<n)
    {
        p=p->next;
        i++;
    }//开始遍历到目标节点i<n是使它能找到该节点，p!=NULL是为了防止超出了链表之外
    if(p==NULL&&i!=n)return false;//防止当你的n大于链表的长度时
    else
    {
        ListNode<T> *q;
        q=new ListNode<T>;
        q->data=t;//?????
        q->next=p->next;
        p->next=q;
        length++;
        return true;
    }
}
template<class T>
void List<T>::deleteNode(int n)
{
    int i=1;
    ListNode<T> *p,*q;
    p=first;
    while(p->next!=NULL&&i!=n)//少了防止n过大的情况
    {
        p=p->next;
        i++;
    }
    q=p->next;
    cout<<"删除数据项:"<<q->data<<endl;//first是没有存储数据的也就是first其实是零号
    p->next=q->next;
    length--;
    delete q;
}
template<class T>
bool List<T>::print()
{
    ListNode<T> *p=first->next;
    if(length==0)
        return false;
    else
    {
        cout<<"链表中有"<<length<<"项数据"<<endl;
        while(p)
        {
            cout<<p->data<<"\t";
            p=p->next;
        }
    }
    cout<<endl;
    return true;
}
template <class T>
int List<T>::find(T t)
{
    ListNode<T> *p=first->next;
    int i=1;
    while(p&&p->data!=t)
    {
        p=p->next;
        i++;
    }
    if(p)return i;
    else return 0;
}
template<class T>
inline List<T>::List()
{
    ListNode<T> *node=new ListNode<T>;
    node->next=NULL;
    first=last=node;
    length=0;
}
template<class T>
List<T>::~List()
{
    ListNode<T> *p;
    while(p=first)
    {
        first=first->next;
        delete p;
    }
}
#include<iostream>
using namespace std;
int main()
{
    List<int>intList;
    intList.insertNode(2,1);
    intList.insertNode(5,2);
    intList.insertNode(100,3);
    intList.print();
    cout<<"50在链表中的位置是："<<intList.find(50)<<endl;
    cout<<"3在链表中的位置是："<<intList.find(3)<<endl;
    intList.deleteNode(1);
    intList.print();
    List<double>doubleList;
    doubleList.insertNode(87.23,1);
    doubleList.insertNode(76.89,2);
    doubleList.insertNode(56.89,3);
    doubleList.insertNode(82.98,4);
    doubleList.insertNode(23.67,2);
    cout<<"\n------doubleList------"<<endl;
    doubleList.print();
    doubleList.empty();
    doubleList.print();
    return 0;
}

在这里，主体是模板类，链表相当于给类寻找空间并将其连接起来，所以在类的成员函数里面可以看到都是定义结构体在里面而且在本例中只对结构体中的data进行操作。

参考文献 C++.NET程序设计