碼上快樂

相關內容    簡體    繁體

（C語言版）鏈表（四）——實現雙向循環鏈表創建、插入、刪除、釋放內存等簡單操作

本文轉載自   查看原文   2017-10-22 11:59   2088    linux

雙向循環鏈表是基於雙向鏈表的基礎上實現的，和雙向鏈表的操作差不多，唯一的區別就是它是個循環的鏈表，通過每個節點的兩個指針把它們扣在一起組成一個環狀。所以呢，每個節點都有前驅節點和后繼節點（包括頭節點和尾節點）這是和雙向鏈表不同的地方。我們看下雙向循環鏈表的示意圖（我在網上找了張圖片，自己畫的實在難看，有時間真的要去學下怎么畫圖了，然后可以寫出更好的博客）：

在程序的編寫方面呢，雙向循環鏈表有點向前面知識的組合，雙向循環鏈表在“雙向”方面和雙向鏈表一樣，在“循環方面”和單向循環鏈表一樣。以前的知識消化了呢，這個雙向循環鏈表也就簡單了。上面這個圖比較形象的體現出了雙向循環鏈表的含義：簡單說呢，就是當前節點的一個指針指向前置節點一個指針指向后繼節點，每個節點都重復這樣，就形成了一個環了。

DbCcLinkList.h 頭文件——包含了節點結構的定義和鏈表相關操作函數的聲明

[cpp] view plain copy
  1. #ifndef DOUBLE_CIRCULAR_LINKED_LIST_H  
  2. #define DOUBLE_CIRCULAR_LINKED_LIST_H  
  3.   
  4. typedef struct Node  
  5. {  
  6.     int data;  
  7.     struct Node *pNext;  
  8.     struct Node *pPre;  
  9. }NODE, *pNODE;  
  10.   
  11. //創建雙向循環鏈表  
  12. pNODE CreateDbCcLinkList(void);  
  13.   
  14. //打印鏈表  
  15. void TraverseDbCcLinkList(pNODE pHead);  
  16.   
  17. //判斷鏈表是否為空  
  18. int IsEmptyDbCcLinkList(pNODE pHead);  
  19.   
  20. //計算鏈表的長度  
  21. int GetLengthDbCcLinkList(pNODE pHead);  
  22.   
  23. //向鏈表中插入節點  
  24. int InsertEleDbCcLinkList(pNODE pHead, int pos, int data);  
  25.   
  26. //從鏈表中刪除節點  
  27. int DeleteEleDbCcLinkList(pNODE pHead, int pos);  
  28.   
  29. //刪除整個鏈表，釋放內存  
  30. void FreeMemory(pNODE *ppHead);  
  31.   
  32. #endif  


DbCcLinkList.cpp 雙向循環鏈表的源文件——包含了鏈表相關操作函數的定義

（1）這部分是用來創建鏈表的，雙向循環鏈表每插入一個節點就要控制4個指針，第一，插入位置的上一個節點有一個指針，它要指向插入節點；第二，插入的節點有兩個指針，一個指向上一個節點，一個指向下一個節點；第三，插入位置的下一個節點有一個指針，它是指着插入節點的。寫程序的關鍵也就是控制好這四個指針，不要弄錯了，要不然會有奇怪的結果（程序出不來結果，無線循環等）

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include "DbCcLinkList.h"  
  4.   
  5. //創建雙向循環鏈表  
  6. pNODE CreateDbCcLinkList(void)  
  7. {  
  8.     int i, length = 0, data = 0;  
  9.     pNODE p_new = NULL, pTail = NULL;  
  10.     pNODE pHead = (pNODE)malloc(sizeof(NODE));  
  11.   
  12.     if (NULL == pHead)  
  13.     {  
  14.         printf("內存分配失敗！\n");  
  15.         exit(EXIT_FAILURE);  
  16.     }  
  17.     pHead->data = 0;  
  18.     pHead->pNext = pHead;  
  19.     pHead->pPre = pHead;  
  20.     pTail = pHead;  
  21.   
  22.     printf("請輸入想要創建鏈表的長度：");  
  23.     scanf("%d", &length);  
  24.   
  25.     for (i=1; i<length+1; i++)  
  26.     {  
  27.         p_new = (pNODE)malloc(sizeof(NODE));  
  28.   
  29.         if (NULL == p_new)  
  30.         {  
  31.             printf("內存分配失敗！\n");  
  32.             exit(EXIT_FAILURE);  
  33.         }  
  34.   
  35.         printf("請輸入第%d個節點元素值：", i);  
  36.         scanf("%d", &data);  
  37.   
  38.         p_new->data = data;  
  39.         p_new->pPre = pTail;  
  40.         p_new->pNext = pHead;  
  41.         pTail->pNext = p_new;  
  42.         pHead->pPre = p_new;  
  43.         pTail = p_new;  
  44.     }  
  45.     return pHead;  
  46. }  

（2）這部分是獲得雙向鏈表的信息，和單向循環鏈表一樣，鏈表結束的限制條件是判斷是否等於頭結點。意思就是從頭節點的下一個節點開始如果又到了頭節點說明已經遍歷一圈了。

[cpp] view plain copy
  1. //打印鏈表  
  2. void TraverseDbCcLinkList(pNODE pHead)  
  3. {  
  4.     pNODE pt = pHead->pNext;  
  5.   
  6.     printf("鏈表打印如：");  
  7.     while (pt != pHead)  
  8.     {  
  9.         printf("%d ", pt->data);  
  10.         pt = pt->pNext;  
  11.     }  
  12.     putchar('\n');  
  13. }  
  14.   
  15. //判斷鏈表是否為空  
  16. int IsEmptyDbCcLinkList(pNODE pHead)  
  17. {  
  18.     pNODE pt = pHead->pNext;  
  19.   
  20.     if (pt == pHead)  
  21.         return 1;  
  22.     else  
  23.         return 0;  
  24. }  
  25.   
  26. //計算鏈表的長度  
  27. int GetLengthDbCcLinkList(pNODE pHead)  
  28. {  
  29.     int length = 0;  
  30.     pNODE pt = pHead->pNext;  
  31.   
  32.     while (pt != pHead)  
  33.     {  
  34.         length++;  
  35.         pt = pt->pNext;  
  36.     }  
  37.     return length;  
  38. }  


（3）這部分是雙向鏈表的插入、刪除節點操作，但是它不需要和雙向鏈表一樣判斷最后一個節點是否為空（因為此時要用到節點的指針），雙向循環鏈表不存在這樣的情況，這是由於它不光是雙向的，而且是循環的，所以每個節點都不可能為空。

[cpp] view plain copy
  1. //向鏈表中插入節點  
  2. int InsertEleDbCcLinkList(pNODE pHead, int pos, int data)  
  3. {  
  4.     pNODE p_new = NULL, pt = NULL;  
  5.     if (pos > 0 && pos < GetLengthDbCcLinkList(pHead) + 2)  
  6.     {  
  7.         p_new = (pNODE)malloc(sizeof(NODE));  
  8.   
  9.         if (NULL == p_new)  
  10.         {  
  11.             printf("內存分配失敗！\n");  
  12.             exit(EXIT_FAILURE);  
  13.         }  
  14.   
  15.         while (1)  
  16.         {  
  17.             pos--;  
  18.             if (0 == pos)  
  19.                 break;  
  20.             pHead = pHead->pNext;  
  21.         }  
  22.           
  23.         p_new->data = data;  
  24.         pt = pHead->pNext;  
  25.         p_new->pNext = pt;  
  26.         p_new->pPre = pHead;  
  27.         pHead->pNext = p_new;  
  28.         pt->pPre = p_new;  
  29.           
  30.         return 1;  
  31.     }  
  32.     else  
  33.         return 0;  
  34. }  
  35.   
  36. //從鏈表中刪除節點  
  37. int DeleteEleDbCcLinkList(pNODE pHead, int pos)  
  38. {  
  39.     pNODE pt = NULL;  
  40.     if (pos > 0 && pos < GetLengthDbCcLinkList(pHead) + 1)  
  41.     {  
  42.         while (1)  
  43.         {  
  44.             pos--;  
  45.             if (0 == pos)  
  46.                 break;  
  47.             pHead = pHead->pNext;  
  48.         }  
  49.         pt = pHead->pNext->pNext;  
  50.         free(pHead->pNext);  
  51.         pHead->pNext = pt;  
  52.         pt->pPre = pHead;  
  53.   
  54.         return 1;  
  55.     }  
  56.     else  
  57.         return 0;     
  58. }  


（4）這是釋放內存操作，和上面講的一樣，不需要判斷最后一個節點是否為空，每次釋放一個節點的內存的以后它還是保持環狀的結構，所以沒有節點為空。

[cpp] view plain copy
  1. //刪除整個鏈表，釋放內存空間  
  2. void FreeMemory(pNODE *ppHead)  
  3. {  
  4.     pNODE pt = NULL;  
  5.     while (*ppHead != NULL)  
  6.     {  
  7.         pt = (*ppHead)->pNext->pNext;  
  8.   
  9.   
  10.         if ((*ppHead)->pNext == *ppHead)  
  11.         {  
  12.             free(*ppHead);  
  13.             *ppHead = NULL;  
  14.         }  
  15.         else  
  16.         {  
  17.             free((*ppHead)->pNext);  
  18.             (*ppHead)->pNext = pt;  
  19.             pt->pPre = *ppHead;  
  20.         }  
  21.     }  
  22. }  


maincpp 測試程序——通過簡單的交互界面判斷函數的功能是否正確

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include "DbCcLinkList.h"  
  4.   
  5. int main(void)  
  6. {  
  7.     int flag = 0, length = 0;  
  8.     int position = 0, value = 0;  
  9.     pNODE head = NULL;  
  10.   
  11.     head = CreateDbCcLinkList();  
  12.       
  13.     flag = IsEmptyDbCcLinkList(head);  
  14.     if (flag)  
  15.         printf("雙向循環鏈表為空！\n");  
  16.     else  
  17.     {  
  18.         length = GetLengthDbCcLinkList(head);  
  19.         printf("雙向循環鏈表的長度為：%d\n", length);  
  20.         TraverseDbCcLinkList(head);  
  21.     }  
  22.       
  23.     printf("請輸入要插入節點的位置和元素值(兩個數用空格隔開)：");  
  24.     scanf("%d %d", &position, &value);  
  25.     flag = InsertEleDbCcLinkList(head, position, value);  
  26.     if (flag)  
  27.     {  
  28.         printf("插入節點成功！\n");  
  29.         TraverseDbCcLinkList(head);  
  30.     }     
  31.     else  
  32.         printf("插入節點失敗！\n");  
  33.       
  34.     flag = IsEmptyDbCcLinkList(head);  
  35.     if (flag)  
  36.         printf("雙向循環鏈表為空，不能進行刪除操作！\n");  
  37.     else  
  38.     {  
  39.         printf("請輸入要刪除節點的位置：");  
  40.         scanf("%d", &position);  
  41.         flag = DeleteEleDbCcLinkList(head, position);  
  42.         if (flag)  
  43.         {  
  44.             printf("刪除節點成功！\n");  
  45.             TraverseDbCcLinkList(head);  
  46.         }     
  47.         else  
  48.             printf("刪除節點失敗！\n");  
  49.     }  
  50.           
  51.     FreeMemory(&head);  
  52.     if (NULL == head)  
  53.         printf("已成功刪除雙向循環鏈表，釋放內存完成！\n");  
  54.     else  
  55.         printf("刪除雙向循環鏈表失敗，釋放內存未完成！\n");  
  56.   
  57.     return 0;  
  58. }  


PS：到這里為止，鏈表的知識就寫到這里了，后面開始就是隊列和棧了。其實線性表方面的知識都大同小異，只要原理清楚之后，它的形式的變化可以是多鍾多樣的，當然本人水平有限，希望能和同道之人繼續深入探討，共同進步。


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 c語言 雙向鏈表的簡單操作-創建、插入、刪除 c語言實現--雙向循環鏈表操作 C語言通用雙向循環鏈表操作函數集 單鏈表，循環鏈表，雙向鏈表（C++實現） 純C語言實現循環雙向鏈表創建，插入和刪除 C++雙向循環鏈表實現 C++實現雙向循環鏈表 雙向循環鏈表 初始化 插入 刪除 c語言實現--單向循環鏈表操作 循環鏈表簡單操作 C++
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM