数据结构之单链表

1. 链表的特点

• 链表是一种非线性、非顺序的物理结构，是由若干个节点组成。
• 链表采用的是“见缝插针”的存储方法，不要求内存连续，靠next指针关联起来。
• 链表的物理存储方式为随机存储，访问方式为顺序访问。
• 查找节点的时间复杂度为O(n)，插入、删除节点的时间复杂度为O(1)。
• 链表适用于写操作多，读操作少的场景。

//单向链表节点的数据结构
struct SingleListNode
{
    int   nData;//当前节点的数据
    Node* pNext;//指向下一个节点的指针
};

//双向链表节点的数据结构
struct DobuleListNode
{
　　int nData;//当前节点的数据
　　Node* pPre;//指向上一个节点的指针
　　Node* pNext;//指向下一个节点的指针
};

2. 链表的基本操作

链表的操作方式主要分为增、删、改、查，下面以单链表为例，分别以最简单的方式介绍基本用法。

首先定义一个单链表数据结构：

struct SingleListNode
{
    int             nVal;
    SingleListNode* pNext;
    SingleListNode():pNext(NULL){}
    SingleListNode(int nTempValue):nVal(nTempValue),pNext(NULL){}
};

class SingleList
{
public:
    SingleList():m_pHead(NULL),m_nSize(0){}
    ~SingleList(){}
public:
    SingleListNode* Find(int nIndex);
    void            Insert(int nIndex,SingleListNode* pNode);
    SingleListNode* Remove(int nIndex);
    void            PrintList();
private:
    SingleListNode* m_pHead;
    int             m_nSize;
};

2.1 查找

链表节点的查找不能通过索引快速定位，只能从头节点开始查找。

SingleListNode* SingleList::Find(int nIndex)
{
    if(nIndex < 0 || nIndex >= m_nSize)
    {
        printf("SingleList::Find:failed! the index is out of range. index is %d 
",nIndex);
        return NULL;
    }

    if(NULL == m_pHead)
    {
        printf("SingleList::Find:failed! the head node is null. 
");
        return NULL;
    }
    
    SingleListNode* pRet = m_pHead;
    for(int i = 0;i < nIndex;i++)
    {
        if(pRet)
        {
            pRet = pRet->pNext;
        }
    }
    return pRet;
}

2.2 更新

首先从列表中查找待更新的节点，直接把旧数据替换为新值即可。

2.3 删除

删除分为三种情况：

• 尾部删除：将倒数第二个节点的next指针只为空。
• 头部删除：将链表头节点设为原头节点的next指针。
• 中间删除：将前置节点的next指针指向待删除节点的next指针。中间删除和尾部删除可以采用同一段代码实现。

SingleListNode* SingleList::Remove(int nIndex)
{
    SingleListNode* pRet = NULL;
    if(nIndex < 0 || nIndex >= m_nSize)
    {
        printf("SingleList::Remove:failed! the index is out of range, size is %d .
 ",m_nSize);
        return pRet;
    }

    if(NULL == m_pHead)
    {
        printf("SingleList::Remove:failed! the head node is null. 
");
        return NULL;
    }

    if(nIndex == 0)
    {
        pRet = m_pHead;
        m_pHead = m_pHead->pNext;
    }
    else
    {
        SingleListNode* pPreNode = Find(nIndex - 1);
        if(pPreNode == NULL)
        {
            printf("SingleList::Remove:failed! the pPre node is null.
 ");
            return pRet;
        }

        pRet = pPreNode->pNext;
        if(pRet)
        {
            pPreNode->pNext = pRet->pNext;
            m_nSize--;
        }
    }
    
    return pRet;
}

2.4 插入

• 尾部插入：将尾节点的next指针指向新插入的节点。
• 头部插入：首先将带插入的节点的next指针头节点，然后将新插入的节点设为链表头节点（注意顺序不能反）。
• 中间插入：首先将新节点的next指针指向插入位置的节点，然后将原始插入位置节点的前置节点的next指针指向新节点（注意顺序不能反）。中间插入和尾部插入可以采用同一段代码实现。

void SingleList::Insert(int nIndex,SingleListNode* pNode)
{
    if(NULL == pNode)
    {
        printf("SingleList::Insert:failed! the pNode is null.
 ");
        return;
    }

    if(nIndex < 0 || nIndex > m_nSize)
    {
        printf("SingleList::Insert:failed! the index is out of range, size is %d .
 ",m_nSize);
        return;
    }

    if(nIndex == 0)
    {
        //first
        pNode->pNext = m_pHead;
        m_pHead = pNode;
    }
    else
    {
        SingleListNode* pPre = Find(nIndex - 1);
        if(pPre == NULL)
        {
            printf("SingleList::Insert:failed! the pPre node is null.
 ");
            return;
        }

        pNode->pNext = pPre->pNext;
        pPre->pNext = pNode;
    }
    m_nSize++;
}

---

3. 链表的应用

常见的面试题中考察链表应用的场景有：

• 两数相加
• 判断链表中是否有环
• 删除链表的倒数第N个节点
• 反转链表（单链表）
• 回文链表
• 合并两个有序链表
  等等，后边会单独出一篇文章介绍面试中常见的链表算法题。