單鏈表的c++實現

鏈表同樣是一種線性表，但只是邏輯上的線性，地址空間並不連續，而是靠指針將各個節點連接起來，就像鎖鏈一樣，一環連一環。所以，需要定義一個節點類，用來存儲數據和指向下一個節點的指針。為了簡單，只定義了兩個公有的成員變量。（雙向鏈表則需定義兩個指針，分別指向前驅和后繼）

#ifndef Node_hpp
#define Node_hpp

class Node
{
public:
    int Data;
    Node *NEXT;
};

#endif /* Node_hpp */

鏈表應該具有線性表的通用功能，所以定義函數為

#ifndef LinkList_hpp
#define LinkList_hpp
#include "Node.hpp"

class LinkList
{
public:
    LinkList();                     //建立鏈表（頭節點）
    ~LinkList();                    //銷毀鏈表
    void ClearList();               //清空鏈表
    bool ListEmpty();               //鏈表判空
    int ListLength();               //鏈表長度
    bool GetElem(int i,Node *pNode);//目標節點內容
    int LocateElem(Node *pNode);    //目標節點位置
    bool PriorElem(Node *pCurrentNode,Node *pPreNode);  //目標節點前驅‘
    bool NextElem(Node *pCurrentNode,Node *pNextNode);  //目標節點后繼
    bool ListInsert(int i,Node *pNode);                 //插入節點
    bool ListDelete(int i,Node *pNode);                 //刪除節點
    bool ListInsertHead(Node *pNode);                   //在鏈表開始處插入
    bool ListInsertTail(Node *pNode);                   //在鏈表尾部插入
    void ListTraverse();                                //遍歷鏈表
private:
    Node *_pList;
    int _iListLen;
};

#endif /* LinkList_hpp */

在建立鏈表的時候，並不需要規定鏈表的容量，因為有需要加入的內容，只需new一個節點類插入進去就可以了。

所以，構造函數只定義了一個頭節點

LinkList::LinkList()
{
    _pList=new Node;
    _pList->Data=0;
    _pList->NEXT=NULL;
    _iListLen=0;
}

刪除鏈表需要依次delete所有節點，而清空鏈表同樣要delete掉除頭節點外所有節點。通過while循環，只要當前節點的NEXT指向不為空，就像下一個節點移動，並刪除當前節點。最后，不忘將當前節點置NULL。

void LinkList::ClearList()
{
    Node *currentNode=_pList->NEXT;
    while(currentNode->NEXT!=NULL)
    {
        Node *temp=currentNode->NEXT;
        delete currentNode;
        currentNode=temp;
    }
    currentNode=NULL;
    _iListLen=0;
}

銷毀鏈表時，只需調用清空函數，最后銷毀頭節點

LinkList::~LinkList()
{
    ClearList();
    delete _pList;
    _pList=NULL;
}

根據頭節點的成員變量_iListLen，可以很容易得到判空函數和長度函數。因為鏈表沒有滿的狀態，所以不需要定義判滿

bool LinkList::ListEmpty()
{
    if(_iListLen==0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

int LinkList::ListLength()
{
    return _iListLen;
}

求目標節點數據和位置有相似的地方，都需要依次遍歷，不同的是求數據的時候要先判斷給的位置是否在規定范圍內，再根據給的位置進行循環，而求位置則是直接從頭遍歷至尾，每次循環都要對比當前節點數據和目標節點數據是否相同（如果遍歷至尾都沒有相同的，則返回-1）

bool LinkList::GetElem(int i,Node *pNode)
{
    if(i<0||i>=_iListLen)
    {
        return false;
    }
    else
    {
        Node *currentNodt=_pList;
        for(int k=0;k<=i;k++)
        {
            currentNodt=currentNodt->NEXT;
        }
        pNode->Data=currentNodt->Data;
        return true;
    }
}

int LinkList::LocateElem(Node *pNode)
{
    Node *currentNode=_pList;
    int k=0;
    while(currentNode->NEXT!=NULL)
    {
        currentNode=currentNode->NEXT;
        if(currentNode->Data==pNode->Data)
        {
            return k;
        }
        k++;
    }
    return -1;
}

求前驅和后繼的方式相似，定義兩個相鄰節點，遍歷的同時移動，並與目標節點數據進行對比，如果求前驅，則用后面的節點對比，如果求后繼，則用前面的節點對比

bool LinkList::PriorElem(Node *pCurrentNode,Node *pPreNode)
{
    Node *currentNode=_pList;
    Node *currentNodeBefore=NULL;
    while(currentNode->NEXT!=NULL)
    {
        currentNodeBefore=currentNode;
        currentNode=currentNode->NEXT;
        if(currentNode->Data==pCurrentNode->Data)
        {
            pPreNode->Data=currentNodeBefore->Data;
            return true;
        }
    }
    return false;
}

bool LinkList::NextElem(Node *pCurrentNode,Node *pNextNode)
{
    Node *currentNode=_pList;
    Node *currentNodeBefore=NULL;
    while(currentNode->NEXT!=NULL)
    {
        currentNodeBefore=currentNode;
        currentNode=currentNode->NEXT;
        if(currentNodeBefore->Data==pCurrentNode->Data)
        {
            pNextNode->Data=currentNode->Data;
            return true;
        }
    }
    return false;
}

插入與刪除與根據位置求數據類似，需要先判斷位置是否合法，再進行遍歷。因為除頭節點外，所有節點都只能由前驅節點的指針得到，所以先賦值插入節點的后繼節點，再將插入節點賦值給前驅節點的后繼。刪除則只需要將目標節點的后繼節點賦值給前驅節點的NEXT指針。

bool LinkList::ListInsert(int i,Node *pNode)
{
    if(i<0||i>=_iListLen)
    {
        return false;
    }
    else
    {
        Node *currentNode=_pList;
        for(int k=0;k<i;k++)
        {
            currentNode=currentNode->NEXT;
        }
        Node *newNode=new Node;
        newNode->Data=pNode->Data;
        newNode->NEXT=currentNode->NEXT;
        currentNode->NEXT=newNode;
        _iListLen++;
        return true;
    }
}

bool LinkList::ListDelete(int i,Node *pNode)
{
    if(ListEmpty())
    {
        return false;
    }
    else
    {
        if(i<0||i>=_iListLen)
        {
            return false;
        }
        else
        {
            Node *currentNode=_pList;
            Node *currentNodeBefore=NULL;
            for(int k=0;k<=i;k++)
            {
                currentNodeBefore=currentNode;
                currentNode=currentNode->NEXT;
            }
            currentNodeBefore->NEXT=currentNode->NEXT;
            pNode->Data=currentNode->Data;
            _iListLen--;
            
            delete currentNode;
            currentNode=NULL;
            return false;
        }
    }
}

在鏈表的頭尾插入則是插入的特殊情況，一個是不需遍歷，一個是需遍歷所有

bool LinkList::ListInsertHead(Node *pNode)
{
    Node *temp=_pList->NEXT;
    Node *newNode=new Node;
    if(newNode==NULL)
    {
        return false;
    }
    else
    {
        newNode->Data=pNode->Data;
        newNode->NEXT=temp;
        _pList->NEXT=newNode;
        _iListLen++;
        return true;
    }
}

bool LinkList::ListInsertTail(Node *pNode)
{
    Node *currentNode=_pList;
    while(currentNode->NEXT!=NULL)
    {
        currentNode=currentNode->NEXT;
    }
    Node *newNode=new Node;
    if(newNode==NULL)
    {
        return false;
    }
    else
    {
        newNode->Data=pNode->Data;
        newNode->NEXT=NULL;
        currentNode->NEXT=newNode;
   
        _iListLen++;
        return true;
    }
}

遍歷鏈表結尾

void LinkList::ListTraverse()
{
    using namespace std;
    
    cout<<endl;
    Node *currentNode=_pList;
    while(currentNode->NEXT!=NULL)
    {
        currentNode=currentNode->NEXT;
        cout<<currentNode->Data<<endl;
    }
    cout<<endl;
}

最后，因為涉及到好多循環，不可避免的有許多循環次數的問題，如果分析不清楚，可以通過在主函數中調用檢驗

#include <iostream>
#include "LinkList.hpp"

int main(int argc, const char * argv[]) {
    // insert code here...
    using namespace std;
    
    LinkList *p=new LinkList;
    
    Node *c=new Node;
    
    c->Data=3;
    p->ListInsertHead(c);
    c->Data=2;
    p->ListInsertHead(c);
    c->Data=5;
    p->ListInsertTail(c);
    c->Data=4;
    p->ListInsert(2,c);
    
    p->ListTraverse();
    
    Node *d=new Node;
    
    p->GetElem(3, d);
    cout<<d->Data<<endl;
    p->PriorElem(c, d);
    cout<<c->Data<<endl;
    cout<<d->Data<<endl;
    p->NextElem(c, d);
    cout<<c->Data<<endl;
    cout<<d->Data<<endl;
    p->ListDelete(2, d);
    cout<<d->Data<<endl;
    
    p->ListTraverse();
    
    delete d;
    d=NULL;
    
    delete c;
    c=NULL;
    
    delete p;
    p=NULL;
    
    return 0;
}
#include <iostream>
#include "LinkList.hpp"

int main(int argc, const char * argv[]) {
    // insert code here...
    using namespace std;
    
    LinkList *p=new LinkList;
    
    Node *c=new Node;
    
    c->Data=3;
    p->ListInsertHead(c);
    c->Data=2;
    p->ListInsertHead(c);
    c->Data=5;
    p->ListInsertTail(c);
    c->Data=4;
    p->ListInsert(2,c);
    
    p->ListTraverse();
    
    Node *d=new Node;
    
    p->GetElem(3, d);
    cout<<d->Data<<endl;
    p->PriorElem(c, d);
    cout<<c->Data<<endl;
    cout<<d->Data<<endl;
    p->NextElem(c, d);
    cout<<c->Data<<endl;
    cout<<d->Data<<endl;
    p->ListDelete(2, d);
    cout<<d->Data<<endl;
    
    p->ListTraverse();
    
    delete d;
    d=NULL;
    
    delete c;
    c=NULL;
    
    delete p;
    p=NULL;
    
    return 0;
}

數據結構線性表基礎部分告一段落