第日一C(链表)

#include <iostream>
using namespace std;


template <class T>
struct LinkNode
{
    T data;
    LinkNode<T> *link;
    LinkNode(LinkNode<T> *ptr = NULL)
    {
        link = ptr;
    }
    LinkNode(const T& item,LinkNode<T>* ptr = NULL)
    {
        data = item;
        link = ptr;
    }

    LinkNode(const T item, LinkNode<T> *ptr)
    {
        data = item;
        link = ptr;
    }
};

template <class T>
class List
{
public:
    List()
    {
        first = new LinkNode<T>;
    }

    List(const T& x)
    {
        first = new LinkNode<T>(x);
    }

    List(List<T>& L);

    ~List()
    {
        makeEmpty();
    }
    void makeEmpty();
    int Length() const;
    LinkNode<T> *getHead() const
    {
        return first;
    }

    LinkNode<T> *search(T x);

    LinkNode<T> *Locate(int x);


    bool getData(int i,T& x);
    void setData(int i,T& x);
    void setData(int i,T x);
    void Push(T& x);
    void Push(T x);

    bool Insert(int i,T& x);
    bool Remove(int i,T& x);
    bool IsEmpty() const
    {
        first->link == NULL ? true : false;
    }

    bool IsFull() const
    {
        return false;
    }

    void Sort();

    void input();

    void output();

    List<T>& operator = (List<T> & L);

protected:
    LinkNode<T> *first;
};

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

template <class T>
LinkNode<T>* List<T>::search(T x)
{
    LinkNode<T> *current = first;
    while(current != NULL)
    {
        if(current->data == x)
        {
            break;
        }
        else current = current->link;
    }
    return current;
}

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

template <class T>
void List<T>::Push(T &x)
{
    LinkNode<T> *current = first;
    while(current->link != NULL)
    {
        current = current->link;
    }
    LinkNode<T> *now = new LinkNode<T>(x);
    now->link = NULL;
    current->link = now;
}

template <class T>
void List<T>::Push(T x)
{
    LinkNode<T> *current = first;
    while(current->link != NULL)
    {
        current = current->link;
    }
    LinkNode<T> *now = new LinkNode<T>(x);
    now->link = NULL;
    current->link = now;
}

template <class T>
bool List<T>::getData(int i, T& x)
{
    if(i <= 0) return NULL;
    LinkNode<T> *current = Locate(i);

    if(current == NULL) return false;
    else
    {
        x = current->data;
        return true;
    }
}

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

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

template <class T>
bool List<T>::Insert(int i, T &x)
{
    LinkNode<T> *current = Locate(i);
    if(current == NULL) return false;
    LinkNode<T> *now = new LinkNode<T>(x);
    if(now == NULL)
    {
        return false;
    }
    now->link = current->link;
    current->link = now;
}

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

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

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






int main()
{
    List<int> *list = new List<int>();
    int value;
    list->setData(0,1);
    list->Push(10);
    list->Push(20);
    list->Push(40);
    list->setData(3,100);
    list->getData(2,value);
    cout << value << endl;

    LinkNode<int>* node = list->search(10);

    list->output();
    return 0;
}