資料結構：雙向連結串列

gaopengtttt發表於2016-09-18
資料結構
原創：轉載請註明
在前面介紹了單項鍊表，
http://blog.itpub.net/7728585/viewspace-2125007/
在實際的應用中雙向連結串列應用也是非常多的，因為我本生是一名DBA，我知道的在資料庫中雙向連結串列應用非常廣泛，在雙向連結串列中
我們多了一個*prior 指向前一個節點，那麼這樣如果我們已知一個節點的指標要求得上一個節點的指標就變得非常簡單了，
時間複雜度由O(n)下降到一個常數O(1),關於這個實現函式我覺得沒必要寫了太簡單了。我準備實現如下一些函式及功能
bool makenode(int datavalue,DULNODEP* p); //makenode next and prior is NULL
void freenode(DULNODEP p); //freenode
bool initlist(LISTHEADP* p); //initlist with no node head last current pointor is NULL
void destroylist(LISTHEADP p); //destroy a list,every list thing is not live
void clearlist(LISTHEADP p);//clear a list,but head is live and head last current pointor is NULL length=0
void insfirst(LISTHEADP h,DULNODEP s);//insfirst  insert one node at first postion length=0
void delfirst(LISTHEADP h); //delete first node current_point to next node
void inslast(LISTHEADP h,DULNODEP s); //inslast  insert one node at last postion
void dellast(LISTHEADP h) ; //delete last node current_point to prior node
void addnode(DULNODEP inode,int postion,LISTHEADP h);//insert one node after postion 
void removenode(int postion,LISTHEADP h) ;//delete node at give postion 
void replacenode(int postion,LISTHEADP h,DULNODEP inode);//replace one node
void viewchain(LISTHEADP h);//show info for chain
void viewheadinfo(LISTHEADP h);//only show head info

我將上一節演示的頭結點增加了last指標指向最後一個節點，同時增加了current指標指向操作的指標。結構體如下：
typedef struct listhead
{
        DULNODEP head;
        DULNODEP last;
        DULNODEP current;
        int length;
} LISTHEAD,*LISTHEADP;

這樣我們在實現inslast和dellast的時候變得非常簡單了，而delfirst和insfirst本來就是通過head指標實現的，如果大家對棧和佇列的實現有了解，著4個函式可以用來實現他們，這個我會在隨後進行說明，這裡只考慮雙線連結串列，我基本上用註釋解釋了全部了功能下面一張圖大概看看雙向連結串列的結構，假設Noden為插入的節點就是如下，刪除也差不多沒畫




下面以程式碼的方式給出實現：

點選(此處)摺疊或開啟

  1. 標頭檔案：
  2. //error(1):delfirst() error list have no
  3. //error(2):getelemp() postion large than lenth or poastion = 0
  4. //error(3):viewchain() list no data

  6. #ifndef _liststr_
  7. #define _liststr_
  8. #define bool int
  9. #define true 1
  10. #define false 0
  11. typedef struct dulnode //node type
  12. {
  13.         int data; //example
  14.         struct dulnode *prior;
  15.         struct dulnode *next;
  16. } DULNODE,*DULNODEP;

  18. typedef struct listhead
  19. {
  20.         DULNODEP head;
  21.         DULNODEP last;
  22.         DULNODEP current;
  23.         int length;
  24. } LISTHEAD,*LISTHEADP;

  26. #define SIZENODE sizeof(DULNODE)
  27. #define SIZELISTHEAD sizeof(LISTHEAD)

  29. bool makenode(int datavalue,DULNODEP* p); //makenode next and prior is NULL
  30. void freenode(DULNODEP p); //freenode
  31. bool initlist(LISTHEADP* p); //initlist with no node head last current pointor is NULL
  32. void destroylist(LISTHEADP p); //destroy a list,every list thing is not live
  33. void clearlist(LISTHEADP p);//clear a list,but head is live and head last current pointor is NULL length=0
  34. void insfirst(LISTHEADP h,DULNODEP s);//insfirst insert one node at first postion length=0
  35. void delfirst(LISTHEADP h); //delete first node current_point to next node
  36. void inslast(LISTHEADP h,DULNODEP s); //inslast insert one node at last postion
  37. void dellast(LISTHEADP h) ; //delete last node current_point to prior node
  38. void addnode(DULNODEP inode,int postion,LISTHEADP h);//insert one elem after postion
  39. void removenode(int postion,LISTHEADP h) ;//delete elem at give postion
  40. void replacenode(int postion,LISTHEADP h,DULNODEP inode);//replace one node
  41. void viewchain(LISTHEADP h);//show info for chain
  42. void viewheadinfo(LISTHEADP h);//only show head info

  44. #endif

點選(此處)摺疊或開啟

  1. 功能函式檔案：
  2. #include<stdlib.h>
  3. #include<stdio.h>
  4. #include <string.h>
  5. #include"dulnode.h"

  7. static DULNODEP getelemp(const LISTHEADP h,int postion) ;

  9. //makenode
  10. bool makenode(int datavalue,DULNODEP* p)
  11. {
  12.         *p = (DULNODEP) malloc (SIZENODE);
  13.         if(!(*p))
  14.         {
  15.                 return false;
  16.         }
  17.         else
  18.         {
  19.                 memset(*p,0,SIZENODE);
  20.                 (*p)->data = datavalue;
  21.                 (*p)->next = NULL;
  22.                 (*p)->prior = NULL;
  23.                 return true;
  24.         }
  25. }

  27. //freenode

  29. void freenode(DULNODEP p)
  30. {
  31.         free(p);
  32. }

  34. //initlist with no node

  36. bool initlist(LISTHEADP* p)
  37. {
  38.         *p = (LISTHEADP)malloc(SIZELISTHEAD);
  39.         if(!*p)
  40.         {
  41.                 return false;
  42.         }
  43.         else
  44.         {
  45.                 memset(*p,0,SIZELISTHEAD);
  46.                 (*p)->head = NULL;
  47.                 (*p)->last = NULL;
  48.                 (*p)->current = NULL;
  49.                 (*p)->length = 0;
  50.                 return true;
  51.         }
  52. }
  53. //destroy a list,every list thing is not live
  54. void destroylist(LISTHEADP p)
  55. {
  56.         DULNODEP npc;
  57.         DULNODEP npn;
  58.         int i = 0;

  60.         if(npc = p->head)
  61.         {
  62.                 npn = p->head->next;
  63.                 for(i=0;i<p->length;i++)
  64.                 {
  65.                         free(npc);
  66.                         npc = npn;
  67.                         if(npn) //last one is null null->next will
  68.                         {
  69.                                 npn = npn->next;
  70.                         }
  71.                 }
  72.         }

  74.         free(p);
  75. }
  76. //clear a list,but head is live
  77. void clearlist(LISTHEADP p)
  78. {
  79.         DULNODEP npc;
  80.         DULNODEP npn;
  81.         int i = 0;

  83.         if(npc = p->head)
  84.         {
  85.                 npn = p->head->next;
  86.                 for(i=0;i<p->length;i++)
  87.                 {
  88.                         free(npc);
  89.                         npc = npn;
  90.                         if(npn) //last one is null null->next will
  91.                         {
  92.                                 npn = npn->next;
  93.                         }
  94.                 }
  95.         }
  96.         p->head = NULL;
  97.         p->last = NULL;
  98.         p->current = NULL;
  99.         p->length = 0;
  100. }

  102. //insfirst insert one node at first postion

  104. void insfirst(LISTHEADP h,DULNODEP s)
  105. {
  106.         if(!(h->head)) //list is empty or not
  107.         {
  108.                 h->head = s;
  109.                 h->last = s;
  110.                 h->current = s;
  111.                 h->length++;
  112.         }
  113.         else
  114.         {
  115.                 h->head->prior = s;
  116.                 s ->next = h->head;
  117.                 h->head = s;
  118.                 h->current = s;
  119.                 h->length++;

  121.         }

  123. }


  126. //delfirst
  127. void delfirst(LISTHEADP h) //delete first node current_point to next node
  128. {
  129.         DULNODEP p;
  130.         if(!(h->head))
  131.         {
  132.                 printf("error(1):delfirst() error list have no node!\n");
  133.                 exit(1);
  134.         }
  135.         else if(!(h->head->next)) //only one node
  136.         {
  137.                 free(h->head);
  138.                 h->head = NULL;
  139.                 h->current = NULL;
  140.                 h->last = NULL;
  141.                 h->length--;
  142.         }
  143.         else
  144.         {
  145.                 p = h->head ;
  146.                 h->head->next->prior = NULL;
  147.                 h->head = h->head->next;
  148.                 h->current = h->head;
  149.                 h->length--;
  150.                 free(p);
  151.         }
  152. }


  155. //inslast insert one node at last postion

  157. void inslast(LISTHEADP h,DULNODEP s)
  158. {
  159.         if(!(h->head)) //list is empty or not
  160.         {
  161.                 h->head = s;
  162.                 h->last = s;
  163.                 h->current = s;
  164.                 h->length++;
  165.         }
  166.         else
  167.         {
  168.                 h->last->next = s;
  169.                 s->prior = h->last;
  170.                 h->last = s;
  171.                 h->current = s;
  172.                 h->length++;
  173.         }
  174. }



  178. //dellast

  180. void dellast(LISTHEADP h) //delete last node current_point to prior node
  181. {
  182.         DULNODEP p;
  183.         if(!(h->head))
  184.         {
  185.                 printf("error(1):delfirst() error list have no node!\n");
  186.                 exit(1);
  187.         }
  188.         else if(!(h->head->next)) //only one node
  189.         {
  190.                 free(h->head);
  191.                 h->head = NULL;
  192.                 h->current = NULL;
  193.                 h->last = NULL;
  194.                 h->length--;
  195.         }
  196.         else
  197.         {
  198.                 p = h->last ;
  199.                 h->last->prior->next = NULL;
  200.                 h->last = p->prior;
  201.                 h->current = p->prior;
  202.                 h->length--;
  203.                 free(p);
  204.         }
  205. }


  208. static DULNODEP getelemp(const LISTHEADP h,int postion)
  209. {
  210.         int i=0;
  211.         DULNODEP p;
  212.         if(postion > h->length || postion ==0 )
  213.         {
  214.                 printf("error(2):getelemp() postion large than lenth or poastion = 0\n");
  215.                 exit(2);
  216.         }
  217.         p = h->head;

  219.         while(i<postion-1)
  220.         {
  221.                 i++;
  222.                 p = p->next;
  223.         }
  224.         return p;
  225. }

  227. //addnode add one node after give postion
  228. void addnode(DULNODEP inode,int postion,LISTHEADP h) //insert one elem after postion
  229. {
  230.         DULNODEP p;
  231.         p = getelemp(h,postion);
  232.         if(!p->next) //last node?
  233.         {
  234.                 p->next = inode;
  235.                 inode->prior = p;
  236.                 inode->next = NULL;
  237.                 h->last = inode;
  238.                 h->current = inode;
  239.         }
  240.         else
  241.         {
  242.                 inode->prior = p;
  243.                 inode->next = p->next;
  244.                 p->next->prior = inode;
  245.                 p->next = inode;
  246.                 h->current = inode;
  247.         }
  248.         h->length++;
  249. }

  251. //removenode remove one node at postion and current point to next postion

  253. void removenode(int postion,LISTHEADP h) //delete elem at give postion
  254. {
  255.         DULNODEP p;
  256.         p = getelemp(h,postion);

  258.         if(postion == 1 && !(p->next)) //node one and only one node
  259.         {
  260.                 h->head = NULL;
  261.                 h->current = NULL;
  262.                 h->last = NULL;
  263.                 free(p);
  264.         }
  265.         else if(postion == 1) //node one?
  266.         {
  267.                 p->next->prior = NULL;
  268.                 h->head = p->next;
  269.                 h->current = h->head;
  270.                 free(p);
  271.         }
  272.         else if(!(p->next)) //last node?
  273.         {
  274.                 h->current = NULL;
  275.                 h->last = p->prior;
  276.                 p->prior->next = NULL;
  277.                 free(p);
  278.         }
  279.         else
  280.         {
  281.                 h->current = p->next;
  282.                 p->next->prior = p->prior;
  283.                 p->prior->next = p->next;
  284.                 free(p);
  285.         }
  286.         h->length--;
  287. }


  290. //replacenode replace one node


  293. void replacenode(int postion,LISTHEADP h,DULNODEP inode)
  294. {
  295.         DULNODEP p;
  296.         p = getelemp(h,postion);

  298.         if(postion == 1 && !(p->next)) //node one and only one node
  299.         {
  300.                 h->head = inode;
  301.                 h->current = inode;
  302.                 h->last = inode;
  303.                 free(p);
  304.         }
  305.         else if(postion == 1)
  306.         {
  307.                 inode->next = h->head->next;
  308.                 h->head->next->prior = inode;
  309.                 h->head = inode;
  310.                 h->current = inode;
  311.                 free(p);
  312.         }
  313.         else if(!(p->next))
  314.         {
  315.                 inode->prior = p->prior;
  316.                 p->prior->next = inode;
  317.                 h->current = inode;
  318.                 h->last = inode;
  319.                 free(p);
  320.         }
  321.         else
  322.         {
  323.                 inode->prior = p->prior;
  324.                 inode->next = p->next;
  325.                 p->prior->next = inode;
  326.                 p->next->prior = inode;
  327.                 h->current = inode;
  328.                 free(p);
  329.         }
  330. }


  333. void viewchain(LISTHEADP h)
  334. {
  335.         int i=1;
  336.         DULNODEP p;
  337.         p = h->head;
  338.         if(!p)
  339.         {
  340.                 printf("error(3):viewchain() list no data\n");
  341.                 exit(3);
  342.         }

  344.         printf("Max chain length is:%d,current_pointor is:%p,head_pointor is:%p,last_pointor is:%p\n",h->length,h->current,h->head,h->last);
  345.         do
  346.         {
  347.                 printf("node:%d values is: %d\n",i,p->data);
  348.                 i++;

  350.         }while(p=p->next);
  351. }

  353. void viewheadinfo(LISTHEADP h)
  354. {

  356.         printf("Max chain length is:%d,current_pointor is:%p,head_pointor is:%p,last_pointor is:%p\n",h->length,h->current,h->head,h->last);
  357. }

點選(此處)摺疊或開啟

  1. 主函式檔案：
  2. #include<stdlib.h>
  3. #include<stdio.h>
  4. #include"dulnode.h"



  8. int main(void)
  9. {
  10.         LISTHEADP headp=NULL;
  11.         DULNODEP p1=NULL;
  12.         DULNODEP p2=NULL;
  13.         DULNODEP p3=NULL;
  14.         DULNODEP p4=NULL;

  16.         DULNODEP p5=NULL;
  17.         DULNODEP p6=NULL;

  19.         if(!(initlist(&headp)))
  20.                 {
  21.                         printf("initlist error\n");
  22.                 }
  23.         if(!(makenode(1,&p1)))
  24.                 {
  25.                         printf("makenode error\n");
  26.                 }
  27.         if(!(makenode(2,&p2)))
  28.         {
  29.                 printf("makenode error\n");
  30.         }
  31.         if(!(makenode(3,&p3)))
  32.         {
  33.                  printf("makenode error\n");
  34.         }
  35.         if(!(makenode(4,&p4)))
  36.         {
  37.                 printf("makenode error\n");
  38.         }

  40.         if(!(makenode(5,&p5)))
  41.         {
  42.                 printf("makenode error\n");
  43.         }

  45.         if(!(makenode(6,&p6)))
  46.         {
  47.                 printf("makenode error\n");
  48.         }

  50.         insfirst(headp,p1);
  51.         insfirst(headp,p2);
  52.         insfirst(headp,p3);
  53.         inslast(headp,p4);

  55.         viewchain(headp);

  57.         delfirst(headp);
  58.         viewchain(headp);
  59.         dellast(headp);
  60.         viewchain(headp);

  62.         addnode(p5,1,headp);
  63.         viewchain(headp);
  64.         replacenode(2,headp,p6);
  65.         viewchain(headp);
  66.         removenode(2,headp);
  67.         viewchain(headp);
  68.         clearlist(headp);
  69.         destroylist(headp);
  70.         return 0;

  72. }

下面我們給出結果來分析：
Max chain length is:4,current_pointor is:0xd210a0,head_pointor is:0xd21080,last_pointor is:0xd210a0
node:1 values is: 3
node:2 values is: 2
node:3 values is: 1
node:4 values is: 4
Max chain length is:3,current_pointor is:0xd21060,head_pointor is:0xd21060,last_pointor is:0xd210a0
node:1 values is: 2
node:2 values is: 1
node:3 values is: 4
Max chain length is:2,current_pointor is:0xd21040,head_pointor is:0xd21060,last_pointor is:0xd21040
node:1 values is: 2
node:2 values is: 1
Max chain length is:3,current_pointor is:0xd210c0,head_pointor is:0xd21060,last_pointor is:0xd21040
node:1 values is: 2
node:2 values is: 5
node:3 values is: 1
Max chain length is:3,current_pointor is:0xd210e0,head_pointor is:0xd21060,last_pointor is:0xd21040
node:1 values is: 2
node:2 values is: 6
node:3 values is: 1
Max chain length is:2,current_pointor is:0xd21040,head_pointor is:0xd21060,last_pointor is:0xd21040
node:1 values is: 2
node:2 values is: 1

首先構造了4個節點前面3個用insfrist 這樣就是 3 2 1的排列最後一個用inslast 那麼就是 3 2 1 4 可以看到確實如此

然後使用delfrist 刪除第一個就是3 那麼剩下 2 1 4 然後使用dellast 那麼刪除 4 就是 2 1 可以看到確實如此

然後我們使用addnode 在位置1後面加入元素 5 那麼就是 2 5 1 確實如此
然後我們使用replacenode 將位置2的元素 data 5的資料換位 data為 6的資料變為 2 6 1
最後呼叫removenode將位置2的元素刪除變為了 2 1 最後是清空和銷燬連結串列。
整個過程預期和測試結果一致

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/7728585/viewspace-2125114/，如需轉載，請註明出處，否則將追究法律責任。

相關文章