练手系列(链表)

简单的单向链表的实现，主要功能包括：链表反转 元素获取 链表合并。

#ifndef _HEADER_LINKLIST_CLASS
#define _HEADER_LINKLIST_CLASS
#include <iostream>
using namespace std;

typedef struct _ListNode
{
    int data;
    _ListNode *pnext;

}ListNode,*pListNode;
class LinkList
{
public:
    LinkList();
    LinkList(int n);
    LinkList(LinkList &list);
    ~LinkList();

    void Add(int data);
    void Del(int npos);                        //delete the node in postion npos
    bool Inverse();                            //inverse the list
    bool PurgeItem(int data);                  //delete the node with const data
    LinkList* MergeList(LinkList *plist1);     //merge the two list of same ascending order
    void PrintAllItem();                       //print all element in list
    int GetSize() {return nsize;}              //return the size of list
    bool GetElement(int &data, int npos);      //get the value in the postion of npos in list
private:
    int nsize;
    pListNode phead;
};
#endif

 

#include "Linklist.h"

LinkList::LinkList()
{
    phead = NULL;
    nsize = 0;
}
LinkList::LinkList(int n)
{
    int i;
    pListNode p;
    pListNode ptemp;
    nsize = n;
    phead = NULL;
    if (n>0)
    {
        phead = new ListNode;
        phead->pnext = NULL;
        phead->data = 0;
        p = phead;
    }
    for (i=0; i<n-1; i++)
    {
        ptemp = new ListNode;
        ptemp->data = 0;
        ptemp->pnext = NULL;
        p->pnext = ptemp;
        p = ptemp;
    }
}
LinkList::LinkList(LinkList &list)
{
    int i;
    pListNode plast;
    pListNode ptemp;
    pListNode psrc  = list.phead;
    phead = NULL;
    nsize = list.nsize;
    //deeply copy
    for (i=0; i<nsize; i++)
    {
        ptemp = new ListNode;
        ptemp->data = psrc->data;
        ptemp->pnext = NULL;
        if(phead == NULL)
        {
            phead = ptemp;
            plast = ptemp;
        }
        else
        {
            plast->pnext = ptemp;
        }
        psrc = psrc->pnext;
    }
}

LinkList::~LinkList()
{
    pListNode p = phead;
    while(nsize)
    {
        Del(nsize-1);
    }
}

void LinkList::Add(int data)
{
    pListNode ptemp1;
    pListNode ptemp2;
    if (phead == NULL)
    {
        ptemp1 = new ListNode;
        phead = ptemp1;
        phead->data = data;
        phead->pnext = NULL;
        nsize++;
    }
    else
    {
        ptemp1 = phead;
        while(ptemp1->pnext != NULL)
        {
            ptemp1 = ptemp1->pnext;
        }
        ptemp2 = new ListNode;
        ptemp2->data = data;
        ptemp2->pnext = NULL;
        ptemp1->pnext = ptemp2;
        nsize++;
    }
}
void LinkList::Del(int npos)
{
    int ncount=0;
    pListNode ptemp = phead;
    pListNode plast;
    if (npos<0 || npos > nsize)
        return;
    while (ptemp != NULL)
    {
        if (ncount == npos && ncount==0)
        {
            //delete the head
            phead = phead->pnext;
            delete ptemp;
            ptemp = phead;
            nsize--;
        }
        else if (ncount == npos)
        {
            plast->pnext = ptemp->pnext;
            delete ptemp;
            ptemp = plast->pnext;
            nsize--;
            continue;
        }
        else
        {
            plast = ptemp;
            ptemp = ptemp->pnext;
        }
        ncount++;
    }
}
bool LinkList::Inverse()
{
    if (phead == NULL)
        return false;
    pListNode pdown=NULL,pcurrent=phead,ptemp1,ptemp2;
    while (pcurrent->pnext != NULL)
    {
        ptemp1 = pcurrent;
        ptemp2 = pdown;
        pcurrent = pcurrent->pnext;
        pdown = ptemp1;
        pdown->pnext = ptemp2;
    }
    phead = pcurrent;
    phead->pnext = pdown;
    return true;
}
bool LinkList::PurgeItem(int data)
{
    pListNode p = phead;
    pListNode plast;
    while (p != NULL)
    {
        if(p->data == data && p==phead)
        {
            delete p;
            phead = p->pnext;
            nsize--;
            return true;
        }
        else if(p->data == data)
        {
            plast->pnext = p->pnext;
            delete p;
            nsize--;
            return true;
        }
        else
        {
            plast = p;
            p = p->pnext;
        }
    }
    return false;
}
/****************************************************
/****precondition:the two list has sorted by some rule
****************************************************/
LinkList* LinkList::MergeList(LinkList *plist1)
{
    LinkList *plistnew = NULL;
    ListNode *ptemp1 = NULL;
    ListNode *ptemp2 = NULL;
    ListNode *ptemp3 = NULL;
    int i;
    if (plist1 == NULL)
    {
        plistnew = new LinkList(nsize);
        ptemp1 = plistnew->phead;
        ptemp2 = phead;
        if (ptemp1==NULL)
            return NULL;
        for (i=0; i<nsize; i++)
        {
            ptemp1->data = ptemp2->data;
            ptemp1=ptemp1->pnext;
            ptemp2=ptemp2->pnext;
        }
    }
    else
    {
        plistnew = new LinkList(nsize+plist1->nsize);
        ptemp1 = plistnew->phead;
        ptemp2 = phead;
        ptemp3 = plist1->phead;
        while (ptemp2 != NULL && ptemp3 != NULL)
        {
            if (ptemp2->data < ptemp3->data)
            {
                ptemp1->data = ptemp2->data;
                ptemp2 = ptemp2->pnext;
            }
            else
            {
                ptemp1->data = ptemp3->data;
                ptemp3 = ptemp3->pnext;
            }
            ptemp1 = ptemp1->pnext;
        }

        while(ptemp2 != NULL)
        {
            ptemp1->data = ptemp2->data;
            ptemp2 = ptemp2->pnext;
            ptemp1=ptemp1->pnext;
        }
        while(ptemp3 != NULL)
        {
            ptemp1->data = ptemp3->data;
            ptemp3 = ptemp3->pnext;
            ptemp1=ptemp1->pnext;
        }
    }
    return plistnew;
}

void LinkList::PrintAllItem()
{
    pListNode p = phead;
    if (p == NULL)
        return;
    printf("All the data in list is:\n");
    while(p!=NULL)
    {
        printf("%d ",p->data);
        p = p->pnext;
    }
    printf("\nending\n");
}
bool LinkList::GetElement(int &data, int npos)
{
    int ntemp = 0;
    int ncount = 0;
    pListNode p = phead;
    if (npos<0 || npos>=nsize)
        return false;
    while (p != NULL)
    {
        if (ncount == npos)
        {
            data = p->data;
            return true;
        }
        ncount++;
        p = p->pnext;
    }
    return false;
}

测试：

#include "Linklist.h"
#include <iostream>
using namespace std;

int main(int argc, char *argv[])
{
    LinkList list1,list2;
    LinkList *pResult;
    int data;
    int ncount = 5;
    cout<<"please input the five element of list1"<<endl;
    while(ncount--)
    {
        scanf("%d",&data);
        list1.Add(data);
    }
    printf("Size of list1 is:%d\n",list1.GetSize());
    list1.PrintAllItem();
    list1.Inverse();
    printf("/************Inverse the list************/\n");
    list1.PrintAllItem();
    printf("/*********get the element in postion 2***/\n");
    list1.GetElement(data,2);
    printf("The element is:%d\n",data);
     printf("/****del the first node wiht data 3******/\n");
     list1.PurgeItem(data);
     list1.PrintAllItem();

     ncount = 5;
     cout<<"please input the five element of list2"<<endl;
     while (ncount--)
     {
         scanf("%d",&data);
         list2.Add(data);
     }
     list2.PrintAllItem();
     pResult = list1.MergeList(&list2);
    //pResult = list1.MergeList(0);
    printf("/********Merge the two list**************/\n");
    pResult->PrintAllItem();

     if (pResult != NULL)
     {
         delete pResult;
         pResult = NULL;
     }
    return 0;
}

结果：