单链表

//2016.9.6
#include <iostream>
#include <cstdio>

using namespace std;

template<class T>
struct node
{
    T date;
    node<T> *next;
    node(node<T> *p = NULL){next = p;}
    node(T a, node<T> *p = NULL){date = a; next = p;}
};

template<class T>
class List
{
private:
    node<T> *head;
public:
    List(){head = new node<T>;}
    List(const T& a){head = new node<T>(a);}
    List(List<T>& L);
    ~List();
    node<T>* get_head(){return head;}
    node<T>* Locate(int pos);
    node<T>* Search(T x);
    int Length();
    bool get_date(int pos, T& x)const;
    void set_date(int pos, T& x);
    bool Insert(int pos, T& x);
    bool Remove(int pos, T& x);
    bool Empty(){return head->next == NULL;}
    void output();
    List<T>& operator=(List<T> &L);
};

template<class T>
List<T>& List<T>::operator=(List<T> &L)
{
    T tmp;
    head = new node<T>;
    node<T>* p = head;
    node<T>* srcptr = L.get_head();
    while(srcptr->next != NULL)
    {
        tmp = srcptr->next->date;
        p->next = new node<T>(tmp);
        p = p->next;
        srcptr = srcptr->next;    
    }
    p->next = NULL;
    return *this;
}

template<class T>
void List<T>::output()
{
    node<T>* p = head->next;
    while(p != NULL)
    {
        cout<<p->date<<" ";
        p = p->next;
    }
    cout<<endl;
}

template<class T>
List<T>::List(List<T>& L)
{
    T tmp;
    head = new node<T>;
    node<T>* p = head;
    node<T>* srcptr = L.get_head();
    while(srcptr->next != NULL)
    {
        tmp = srcptr->next->date;
        p->next = new node<T>(tmp);
        p = p->next;
        srcptr = srcptr->next;
    }
    p->next = NULL;
}

template<class T>
List<T>::~List()
{
    node<T> *p;
    while(head->next != NULL)
    {
        p = head->next;
        head->next = p->next;
        delete p;
    }
}

template<class T>
node<T>* List<T>::Search(T x)
{
    node<T>* cur = head->next;
    while(cur->next != NULL)
    {
        if(cur->date == x)return cur;
        cur = cur->next;
    }
    return NULL;
}

template<class T>
node<T>* List<T>::Locate(int pos)
{
    if(pos < 0)return NULL; 
    node<T>* p = head;
    for(int i = 0; i < pos && p->next != NULL; i++, p = p->next)
    ;
    return p;
}

template<class T>
int List<T>::Length()
{
    int cnt = 0;
    node<T> p = head-next;
    while(p->next != NULL)
    {
        cnt++;
        p = p->next;
    }
    return cnt;
}

template<class T>
bool List<T>::get_date(int pos, T& x)const
{
    if(pos < 0)return false;
    node<T>* cur = Locate(pos);
    if(cur==NULL)return false;
    x = cur->date;
    return true;
}

template<class T>
void List<T>::set_date(int pos, T& x)
{
    if(pos < 0)return ;
    node<T>* cur = Locate(pos);
    if(cur == NULL)return;
    cur->date = x;
}

template<class T>
bool List<T>::Insert(int pos, T& x)
{
    node<T>* cur = Locate(pos);
    if(cur == NULL)return false;
    node<T>* p = new node<T>(x);
    if(p == NULL)exit(1);
    p->next = cur->next;
    cur->next = p;
    return true;
}

template<class T>
bool List<T>::Remove(int pos, T& x)
{
    node<T>* cur = Locate(pos-1);
    if(cur == NULL || cur->next == NULL)return false;
    node<T>* p = cur->next;
    cur->next = p->next;
    x = p->date; delete p;
    return true;
}

int main()
{
    List<int> lis;
    int a;
    for(int i = 0; i < 10; i++)
    {
        lis.Insert(0, i);
    }
    lis.output();
    lis.Remove(1, a);
    lis.output();
    a = 300;
    lis.set_date(3, a);
    lis.output();
    List<int> lis2 = lis;
    lis2.output();
    cout<<"OK"<<endl;
    return 0;
}