链表的一些具体实现代码

什么是数据结构？

简单来说，数据结构是以某种特定的布局方式存储数据的容器。这种“布局方式”决定了数据结构对某些操作是高效的，而对于其他操作则是低效的。

常见的数据结构分为8种类型

分别是：数组，栈，队列，树，图，链表，哈希表，字典树

链表分为单链表和双链表：

单链表只有一个指向下一节点的指针，也就是只能是next

双链表，除了一个能指向下一节点的指针，还有一个指向前一节点的指针，可以通过prev()快速找到前一节点。

以下对链表进行专门的总结:

1.求单链表中节点的个数

//求单链表中节点的个数
//检查下一个链表是否为空
unsigned int getListLength(ListNode * pHead){
    if(pHead == NULL)
        return 0;
        unsigned int nLength = 0;
        ListNode * pCurrent = pHead;
        while(pCurrent != NULL){
            nLength++;
            pCurrent = pCurrent->m_pNext;
        }
           return nLength;
}

2.将单链表反转

//反转单链表
//从头到尾遍历原链表，没遍历一个节点，将其摘下放在新链表的最前端

ListNode * ReverseList(ListNode * pHead){
    //如果链表为空或只有一个节点，无需反转，直接返回原链表头指针
    if(pHead == NULL || pHead->m_pNext == NULL)
        return pHead;
    //反转后的新链表头指针，初始为null
    ListNode * pReversedHead = NULL;
    //反转后的尾指针
    ListNode * pCurrent = pHead;
    while(pCurrent != NULL){
        ListNode * pTemp = pCurrent;
        pCurrent = pCurrent->m_pNext;
        //将当前节点摘下，插入新链表的最前端
        pTemp->m_pNext = pReversedHead;
        pReversedHead = pTemp;
    }
       return pReversedHead;
}

3.查找单链表中的倒数第k个节点（k>0）

//查找单链表中倒数第k个节点
//使用两个指针，先让前面的指针走到正向第k个节点，然后前面的指针跟最后一个指针同时往前走，前这个指针//走到头的时候，后面的节点就是倒数第k个节点
ListNode * RGetKthNode(ListNode * pHead,unsigned int k){
    if(k==0 || pHead==NULL)
        return NULL;
    ListNode * pAhead=pHead;
    ListNode * pBehind=pHead;
    while(k>1 && pAhead !=NULL){
        pAhead = pAhead->m_pNext;
        k--;        
    }
    if(k>1)
        return NULL;
    while(pAhead->m_pNext != NULL){
        pBehind = pBehind->m_pNext;
        pAhead = pAhead->m_pNext;
    }
       return pBehind;
}

4.查找单链表的中间节点

//设置两个指针，两个指针同时向前走，前面的指针每次走两步，后面的指针每次走一步，前面的指针走到最后一个结点时，后面的指针所指结点就是中间结点，即第（n/2+1）个结点
 // 获取单链表中间结点，若链表长度为n(n>0)，则返回第n/2+1个结点  
  ListNode * GetMiddleNode(ListNode * pHead)  
  {  
      if(pHead == NULL || pHead->m_pNext == NULL) // 链表为空或只有一个结点，返回头指针  
         return pHead;  
   
      ListNode * pAhead = pHead;  
      ListNode * pBehind = pHead; 
    // 前面指针每次走两步，直到指向最后一个结点，后面指针每次走一步   
      while(pAhead->m_pNext != NULL) 
     {  
         pAhead = pAhead->m_pNext;  
         pBehind = pBehind->m_pNext;  
         if(pAhead->m_pNext != NULL)  
             pAhead = pAhead->m_pNext;  
     }  
     return pBehind; // 后面的指针所指结点即为中间结点  
 }  

5.从尾到头打印单链表

//对于这种颠倒顺序的问题，我们应该就会想到栈，后进先出。所以，这一题要么自己使用栈，要么让系统使用栈，也就是递归。


  // 从尾到头打印链表，使用栈  
  void RPrintList(ListNode * pHead)  
  {  
      std::stack<ListNode *> s;  
      ListNode * pNode = pHead;  
      while(pNode != NULL)  
      {  
          s.push(pNode);  
          pNode = pNode->m_pNext;  
     }  
     while(!s.empty())  
     {  
         pNode = s.top();  
         printf("%d\t", pNode->m_nKey);  
         s.pop();  
     }  
 }  

使用递归

  // 从尾到头打印链表，使用递归  
  void RPrintList(ListNode * pHead)  
  {  
      if(pHead == NULL)  
      {  
          return;  
      }  
      else  
      {  
         RPrintList(pHead->m_pNext);  
         printf("%d\t", pHead->m_nKey);  
     }  
 }

6.已知两个单链表pHead1和pHead2各自有序，把他们合并成一个链表依然有序

//注意两个链表都为空，和其中一个为空时的情况
// 合并两个有序链表  
  ListNode * MergeSortedList(ListNode * pHead1, ListNode * pHead2)  
  {  
      if(pHead1 == NULL)  
          return pHead2;  
      if(pHead2 == NULL)  
          return pHead1;  
      ListNode * pHeadMerged = NULL;  
      if(pHead1->m_nKey < pHead2->m_nKey)  
     {  
         pHeadMerged = pHead1;  
         pHeadMerged->m_pNext = NULL;  
         pHead1 = pHead1->m_pNext;  
     }  
     else  
     {  
         pHeadMerged = pHead2;  
         pHeadMerged->m_pNext = NULL;  
         pHead2 = pHead2->m_pNext;  
     }  
     ListNode * pTemp = pHeadMerged;  
     while(pHead1 != NULL && pHead2 != NULL)  
     {  
         if(pHead1->m_nKey < pHead2->m_nKey)  
         {  
             pTemp->m_pNext = pHead1;  
             pHead1 = pHead1->m_pNext;  
             pTemp = pTemp->m_pNext;  
             pTemp->m_pNext = NULL;  
         }  
         else  
         {  
             pTemp->m_pNext = pHead2;  
             pHead2 = pHead2->m_pNext;  
             pTemp = pTemp->m_pNext;  
             pTemp->m_pNext = NULL;  
         }  
     }  
     if(pHead1 != NULL)  
         pTemp->m_pNext = pHead1;  
     else if(pHead2 != NULL)  
         pTemp->m_pNext = pHead2;  
     return pHeadMerged;  
 } 

7.判断一个单链表红是否有环

//用两个指针去遍历，一个指针一次走两步，一个指针一次走一步，如果有环，两个指针肯定会在环中相遇
    bool HasCircle(ListNode * pHead)  
      {  
          ListNode * pFast = pHead; // 快指针每次前进两步  
          ListNode * pSlow = pHead; // 慢指针每次前进一步  
          while(pFast != NULL && pFast->m_pNext != NULL)  
              {  
                  pFast = pFast->m_pNext->m_pNext;  
                  pSlow = pSlow->m_pNext;  
                  if(pSlow == pFast) // 相遇，存在环  
                     return true;  
             }  
                     return false;  
       }  

8.判断两个单链表是否相交

//如果两个链表相交，那么最后一个节点肯定是共有的
    bool IsIntersected(ListNode * pHead1, ListNode * pHead2)  
  {  
          if(pHead1 == NULL || pHead2 == NULL)  
                  return false;  
    
      ListNode * pTail1 = pHead1;  
      while(pTail1->m_pNext != NULL)  
          pTail1 = pTail1->m_pNext;  
    
     ListNode * pTail2 = pHead2;  
     while(pTail2->m_pNext != NULL)  
         pTail2 = pTail2->m_pNext;  
     return pTail1 == pTail2;  
 } 

9.求两个单链表相交的第一个节点

/*对第一个链表遍历，计算长度len1，同时保存最后一个节点的地址。
对第二个链表遍历，计算长度len2，同时检查最后一个节点是否和第一个链表的最后一个节点相同，若不相同，不相交，结束。
两个链表均从头节点开始，假设len1大于len2，那么将第一个链表先遍历len1-len2个节点，此时两个链表当前节点到第一个相交节点的距离就相等了，然后一起向后遍历，知道两个节点的地址相同。*/
 ListNode* GetFirstCommonNode(ListNode * pHead1, ListNode * pHead2)  
  {  
      if(pHead1 == NULL || pHead2 == NULL)  
          return NULL;  
    
      int len1 = 1;  
      ListNode * pTail1 = pHead1;  
      while(pTail1->m_pNext != NULL)  
      {  
         pTail1 = pTail1->m_pNext;  
         len1++;  
     }  
   
     int len2 = 1;  
     ListNode * pTail2 = pHead2;  
     while(pTail2->m_pNext != NULL)  
     {  
         pTail2 = pTail2->m_pNext;  
         len2++;  
     }  
   
     if(pTail1 != pTail2) // 不相交直接返回NULL  
         return NULL;  
   
     ListNode * pNode1 = pHead1;  
     ListNode * pNode2 = pHead2;  
         // 先对齐两个链表的当前结点，使之到尾节点的距离相等  
     if(len1 > len2)  
     {  
         int k = len1 - len2;  
         while(k--)  
             pNode1 = pNode1->m_pNext;  
     }  
     else  
     {  
         int k = len2 - len1;  
         while(k--)  
             pNode2 = pNode2->m_pNext;  
     }  
     while(pNode1 != pNode2)  
     {  
         pNode1 = pNode1->m_pNext;  
         pNode2 = pNode2->m_pNext;  
     }  
         return pNode1;  
 } 

10.已知一个单链表中存在环，求进入环中的第一个节点

//首先判断是否存在环，若不存在结束。在环中的一个节点处断开（当然函数结束时不能破坏原链表），这样就形成了两个相交的单链表，求进入环中的第一个节点也就转换成了求两个单链表相交的第一个节点
  ListNode* GetFirstNodeInCircle(ListNode * pHead)  
  {  
      if(pHead == NULL || pHead->m_pNext == NULL)  
          return NULL;  
    
      ListNode * pFast = pHead;  
      ListNode * pSlow = pHead;  
      while(pFast != NULL && pFast->m_pNext != NULL)  
     {  
         pSlow = pSlow->m_pNext;  
         pFast = pFast->m_pNext->m_pNext;  
         if(pSlow == pFast)  
             break;  
     }  
     if(pFast == NULL || pFast->m_pNext == NULL)  
         return NULL;  
   
     // 将环中的此节点作为假设的尾节点，将它变成两个单链表相交问题  
     ListNode * pAssumedTail = pSlow;   
     ListNode * pHead1 = pHead;  
     ListNode * pHead2 = pAssumedTail->m_pNext;  
   
     ListNode * pNode1, * pNode2;  
     int len1 = 1;  
     ListNode * pNode1 = pHead1;  
     while(pNode1 != pAssumedTail)  
     {  
         pNode1 = pNode1->m_pNext;  
         len1++;  
     }  
       
     int len2 = 1;  
     ListNode * pNode2 = pHead2;  
     while(pNode2 != pAssumedTail)  
     {  
         pNode2 = pNode2->m_pNext;  
         len2++;  
     }  
   
     pNode1 = pHead1;  
     pNode2 = pHead2;  
     // 先对齐两个链表的当前结点，使之到尾节点的距离相等  
     if(len1 > len2)  
     {  
         int k = len1 - len2;  
        while(k--)  
             pNode1 = pNode1->m_pNext;  
     }  
     else  
     {  
         int k = len2 - len1;  
         while(k--)  
             pNode2 = pNode2->m_pNext;  
     }  
     while(pNode1 != pNode2)  
     {  
         pNode1 = pNode1->m_pNext;  
         pNode2 = pNode2->m_pNext;  
     }  
     return pNode1;  
 }

11.给出一个单链表头指针pHead和一节点指针pToBeDeleted，删除这个节点

  void Delete(ListNode * pHead, ListNode * pToBeDeleted)  
  {  
      if(pToBeDeleted == NULL)  
          return;  
      if(pToBeDeleted->m_pNext != NULL)  
      {  
          pToBeDeleted->m_nKey = pToBeDeleted->m_pNext->m_nKey; // 将下一个节点的数据复制到本节点，然后删除下一个节点  
          ListNode * temp = pToBeDeleted->m_pNext;  
          pToBeDeleted->m_pNext = pToBeDeleted->m_pNext->m_pNext;  
         delete temp;  
     }  
     else // 要删除的是最后一个节点  
     {  
         if(pHead == pToBeDeleted) // 链表中只有一个节点的情况  
         {  
             pHead = NULL;  
             delete pToBeDeleted;  
         }  
         else  
         {  
             ListNode * pNode = pHead;  
             while(pNode->m_pNext != pToBeDeleted) // 找到倒数第二个节点  
                 pNode = pNode->m_pNext;  
             pNode->m_pNext = NULL;  
             delete pToBeDeleted;  
        }     
     }  
 }