单链表的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;
}

数据结构线性表基础部分告一段落