Implement a single linklist

来源：互联网发布：男士通勤包推荐知乎编辑：程序博客网时间：2024/06/05 05:32
//LinkList.h 
#include<iostream> 
using namespace std;
template<typename T>
//Node for LinkList 
struct Node
{
    T data;
    Node<T>* next;        //the link for next node 
    Node(Node<T>* ptr=NULL)
    {
        next = ptr;
    }
    Node(const T& item,Node<T>* ptr=NULL)
    {
        data = item,next = ptr;
    }
};
template<typename T>
class LinkList
{
    Node<T>* head;
public:
    LinkList();
    LinkList(const T& item);
    LinkList(LinkList<T>& );
    LinkList<T>& operator=(LinkList<T>& L);
    ~LinkList();
    //////////////////////////////// 
    int Length() const; //calculate the length of LinkList 
    T GetData(int i);    //get the value of ith element 
    void SetHead(Node<T>* );
    void CreateList();    //create list by insert back method 
    void MakeEmpty();
    void Display();
    Node<T>* GetHead()const;
    Node<T>* Search(T x);   //find address of 'x' 
    Node<T>* Locate(int i);  //find address of ith element 
    bool Insert(int i,T& x);  //insert value 'x' after ith element 
    bool Delete(int i,T& x);  //remove the ith element,and return it's value by 'x' 
    bool IsEmpty()const;
    bool IsFull()const;
};
///////////////////////////////////////////// 
//LinkList.cpp 
#include "LinkList.h" 
template<typename T>
LinkList<T>::LinkList()
{
    head = new Node<T>;
}
template<typename T>
LinkList<T>::LinkList(const T& x)
{
    head = new Node<T> (x);
}
template<typename T>
LinkList<T>::LinkList(LinkList<T>& L)
{
    T value;
    Node<T> *p = L.GetHead();
    Node<T> *q = head = new Node<T>;
    while (p->next)
    {
        value = p->next->data;
        q ->next = new Node<T> (value);  //copy constructor 
        q = q->next,p = p->next;
    }
    q->next = NULL;   // 
}
template<typename T>
LinkList<T>& LinkList<T>::operator=(LinkList<T>& L)  //overload operator '=' 
{
    if (this == &L) return this;
    T value;
    Node<T>* p = L.GetHead();
    Node<T>* q = head = new Node<T>;
    while (p->next)
    {
        value = p->next->data;
        q->next = new Node<T> (value);
        p = p->next,q = q->next;
    }
    q->next = NULL;
    return *this;
}
template<typename T>
LinkList<T>::~LinkList()
{
    MakeEmpty();
}
/////////////////////////////////////////////////////////////////////////// 
template<typename T>
int LinkList<T>::Length()const
{
    Node<T>* p = head->next;
    int count = 0;
    while (p)
    {
        count++,p = p->next;
    }
    return count;
}
template<typename T>
T LinkList<T>::GetData(int i)
{
    if (i<0) return NULL;
    Node<T>* p = Locate(i);
    if (p == NULL) return -1;   //i overflow... 
    return p->data;
}
template<typename T>
inline void LinkList<T>::SetHead(Node<T>* p)
{
    head = p;
}
template<typename T>
void LinkList<T>::CreateList()   //insert back 
{
    Node<T> *newNode,*last;
    head = new Node<T>;
    if (head == NULL) exit(1);   //allocation memroy error.. 
    cout<<"create list now,please input the node's value"<<endl;
    cout<<"terminate by push 'Ctrl+Z'"<<endl;
    T val;
    last = head;
    while (cin>>val)
    {
        newNode = new Node<T> (val);
        if (newNode == NULL) exit(1);   //allocation error 
        last->next = newNode;
        last = newNode;
    }
    last->next = NULL;
}
template<typename T>
void LinkList<T>::MakeEmpty()
{
    Node<T>* p;
    while (head->next)
    {
        p = head->next, head->next = p->next;
        delete p;
    }
}
template<typename T>
void LinkList<T>::Display()
{
    Node<T>* p = head->next;
    while (p)
    {
        cout<<p->data<<"  ";
        p = p->next;
    }
    cout<<endl;
}
template<typename T>
Node<T>* LinkList<T>::Locate(int i)
{
    if (i<0) return NULL;
    Node<T>* p = head;
    int k = 0;
    while (p && k<i)
    {
        p = p->next,k++;
    }
    return p;
}
template<typename T>
inline Node<T>* LinkList<T>::GetHead()const
{
    return head;
}
template<typename T>
Node<T>* LinkList<T>::Search(T x)
{
    Node<T>* p = head->next;
    while (p)
    {
        if (p->data == x) break;   // 
        p = p->next;
    }
    return p;
}
template<typename T>
bool LinkList<T>::Insert(int i,T& x)
{
    Node<T>* p = Locate(i);
    if (p == NULL) return false;
    Node<T>* newNode = new Node<T> (x);
    if (newNode == NULL) exit(1);   //allocation error 
    newNode->next = p->next;
    p->next = newNode;
    return true;
}
template<typename T>
bool LinkList<T>::Delete(int i,T& x)
{
    Node<T>* p = Locate(i-1);
    if (p==NULL || p->next==NULL) return false;
    Node<T>* del = p->next;
    p->next = del->next, x = del->data;
    delete del;
    return true;
}
template<typename T>
bool LinkList<T>::IsEmpty()const
{
    return (head->next == NULL) ? true : false;
}
template<typename T>
bool LinkList<T>::IsFull()const
{
    return false;
}
///////////////////////////////////////////////////////// 
//main.cpp 
#include "LinkList.cpp" 
int main(void)              //a simple test 
{
    LinkList<int> List_Obj;
    List_Obj.CreateList();  //litter test ...... 
    cout<<"the length of LinkList is "<<List_Obj.Length()<<endl;
    List_Obj.Display();
    int a = 100;
    List_Obj.Insert(2,a);
    List_Obj.Display();
    List_Obj.Delete(5,a);
    if (List_Obj.Delete(5,a)) cout<<"remove succeed...yeah"<<endl;
    else cout<<"fail to remove"<<endl;
    List_Obj.Display();
    return 0;
}