資料結構：連結串列的初始化插入和刪除2.3.1

gaopengtttt發表於2016-09-14
資料結構
前面我們已經說了線性表的順序實現，
http://blog.itpub.net/7728585/viewspace-2124937/
下面我們將討論一下線性表的連結串列實現。
連結串列結構使用得非常多，不管是作業系統還是資料庫都是使用非常頻繁的一種資料結構，
由於其相對靈活的記憶體使用，並且快速的插入和刪除，都是非常有優勢的。
這裡通過C語言實現5個功能：
1、使用線性表的順序結構初始化連結串列結構
2、初始化連結串列結構為指定的大小
3、獲取連結串列中的指定位置的元素
4、在指定位置後面插入一個元素
5、刪除指定位置的元素
先來看一個大概的圖，說明是是加NODENEW加入到節點NODE1後面的情況，實際上刪除也是類似，具體實現看程式碼

首先我們需要定義個頭結點指向第一個NODE，NODE中有NEXT指標指向下一個結點，在這種結構中，
檢視固定元素的時間複雜度最壞也是O(n)，而插入一元素時間複雜度為O(1)，刪除一個元素複雜度也是O(1)
但是我們應該清楚如果要插入指定位置或者刪除指定位置的元素首先需要的是查詢，那麼需要的時間則是他們
相加。來看C語言實現，在整個程式碼檔案中沒有使用標頭檔案導致每個檔案都需要定義一些需要的定義！同時我
使用了函式過載來實現
1、使用線性表的順序結構初始化連結串列結構
2、初始化連結串列結構為指定的大小
不可避免的引入了一點點C++的知識

點選(此處)摺疊或開啟

  1. 順序表實現：
  2. /*************************************************************************
  3.   > File Name: sqlist.cpp
  4.   > Author: gaopeng
  5.   > Mail: gaopp_200217@163.com
  6.   > Created Time: Wed 05 Oct 2016 02:44:35 AM CST
  7.  ************************************************************************/

  9. #include<iostream>
  10. #include<stdio.h>
  11. #include<stdlib.h>
  12. #include<string.h>
  13. #define INITSIZE 10

  15. typedef unsigned int uint;
  16. typedef int Etype;

  18. typedef struct sqlist
  19. {
  20.         Etype* elem; //pointer of sqlist base address
  21.         uint length; //current length of elem
  22.         uint m_size; //
  23. } SQLIST;


  26. void initsqlist(SQLIST* inlist)
  27. {

  29.         inlist->elem = (Etype* )malloc(sizeof(Etype)*INITSIZE + 1);
  30.         inlist->length = 0;
  31.         inlist->m_size = INITSIZE; //maxsize
  32. }


  35. void initsqlinsert(SQLIST* inlist,Etype ielem,uint postion) //insert elem before postion
  36. {

  38.         int i;
  39.         Etype* newbase;
  40.         if(postion > inlist->length + 1 || postion < 1)
  41.         {

  43.                 printf("line table must continuous or postion must>0!\n");
  44.                 exit(1);
  45.         }

  47.         if(inlist->length + 1 >= inlist->m_size ) //if memory small will give more memory
  48.         {

  50.                 if(!(newbase =(Etype* )realloc(inlist->elem,(inlist->length+INITSIZE)* sizeof(Etype)+1)))
  51.                 {

  53.                         printf("mem alloc failed!\n");
  54.                         exit(2);
  55.                 }
  56.                 inlist->elem = newbase;
  57.                 inlist->m_size = inlist->m_size+INITSIZE;
  58.         }

  60.         for(i=0;i<(inlist->length-postion+2);i++) //every elem houyi
  61.         {

  63.                 *(inlist->elem+inlist->length+1-i) = * (inlist->elem+inlist->length-i);
  64.         }
  65.         *(inlist->elem+inlist->length+1-i) = ielem; //give value
  66.         inlist->length =inlist->length+1;
  67. }

  69. void delsqldel(SQLIST* inlist,uint postion) //delete elem of postion
  70. {

  72.         int i;
  73.         if((postion > inlist->length) ||(postion <1))
  74.         {

  76.                 printf("give postion is must large than 1 and less than current length\n");
  77.         }

  79.         for(i=0;i<(inlist->length-postion) ;i++)
  80.         {

  82.                 *(inlist->elem+postion+i) = *(inlist->elem+postion+i+1);
  83.         }
  84.         inlist->length =inlist->length-1;
  85. }

  87. void view(SQLIST* inlist)
  88. {

  90.         int i;
  91.         if(inlist->length ==0 )
  92.         {

  94.                 printf("init data arrary! no data found!\n");
  95.                 exit(3);
  96.         }
  97.         for(i=0;i<inlist->length;i++)
  98.         {

  100.                 printf("node:%d values is:%d data length:%d max_size:%d \n",i,*(inlist->elem+i),inlist->length,inlist->m_size);
  101.         }
  102. }


點選(此處)摺疊或開啟

  1. 連結串列實現：
  2. #include<iostream>
  3. #include<stdio.h>
  4. #include <stdlib.h>
  5. typedef int datatype;
  6. typedef int Etype;
  7. typedef unsigned int uint;

  9. typedef struct node
  10. {
  11.         datatype data;
  12.         struct node *next;
  13. } Node,*Nodep;

  15. typedef struct hnode
  16. {
  17.         int clenth;
  18.         Nodep headp;
  19. } Hnode,*Hnodep;


  22. typedef struct sqlist
  23. {
  24.         Etype* elem; //pointer of sqlist base address
  25.         uint length; //current length of elem
  26.         uint m_size; //
  27. } SQLIST;

  29. void initchain(Hnodep hnode,int n)
  30. {
  31.         Nodep p;
  32.         int i;
  33.         hnode->clenth = 0;
  34.         hnode->headp = (Nodep)malloc(sizeof(Node));
  35.         hnode->headp->next = NULL;
  36.         hnode->headp->data = 0;
  37.         (hnode->clenth)++;
  38.         for(i=(n-1);i>0;--i)
  39.         {
  40.                 p = (Nodep)malloc(sizeof(Node));
  41.                 p->next = hnode->headp->next;
  42.                 hnode->headp->next = p;
  43.                 p->data = 0;
  44.                 (hnode->clenth)++;
  45.         }
  46. }


  49. void initchain(Hnodep hnode,const SQLIST* sqdata)
  50. {
  51.         Nodep p;
  52.         int i;
  53.         int t=1;
  54.         int sqlen = sqdata->length;
  55.         hnode->clenth = 0;
  56.         hnode->headp = (Nodep)malloc(sizeof(Node));
  57.         hnode->headp->next = NULL;
  58.         hnode->headp->data = *(sqdata->elem);
  59.         (hnode->clenth)++;
  60.         sqlen--;
  61.         for(i=sqlen;i>0;--i)//every time insert elem after first elem and before seconed elem
  62.         {
  63.                 p = (Nodep)malloc(sizeof(Node));
  64.                 p->next = hnode->headp->next;
  65.                 hnode->headp->next = p;
  66.                 p->data = *(sqdata->elem+t);
  67.                 (hnode->clenth)++;
  68.                 t++;
  69.         }
  70. }


  73. void viewchain(Hnodep hnode)
  74. {
  75.         int i=1;
  76.         Nodep p;
  77.         int max_len;
  78.         p = hnode->headp;
  79.         max_len = hnode->clenth;

  81.         printf("Max chain length is:%d\n",max_len);
  82.         do
  83.         {
  84.                 printf("node:%d values is: %d\n",i,p->data);
  85.                 i++;

  87.         }while(p=p->next);
  88. }

  90. void getelem(Hnodep hnode,int postion)
  91. {
  92.         int i=0;
  93.         Nodep p;
  94.         if(postion > hnode->clenth || postion ==0 )
  95.         {
  96.                 printf("postion large than lenth or poastion = 0\n");
  97.                 exit(4);
  98.         }
  99.         p = hnode->headp;

  101.         while(i<postion-1)
  102.         {
  103.                 i++;
  104.                 p = p->next;
  105.         }

  107.         printf("node %d values is %d\n",i+1,p->data);

  109. }


  112. Nodep getelemp(const Hnodep hnode,int postion) //insert one elem after postion
  113. {
  114.         int i=0;
  115.         Nodep p;
  116.         if(postion > hnode->clenth || postion ==0 )
  117.         {
  118.                 printf("postion large than lenth or poastion = 0\n");
  119.                 exit(5);
  120.         }
  121.         p = hnode->headp;

  123.         while(i<postion-1)
  124.         {
  125.                 i++;
  126.                 p = p->next;
  127.         }

  129.         return p;

  131. }

  133. void addnode(Nodep inode,int postion,Hnodep hnode)//insert one elem after postion
  134. {
  135.         Nodep p;
  136.         p = getelemp(hnode,postion);
  137.         if(!p->next) //end elem?
  138.         {
  139.                 p->next = inode;
  140.                 inode->next = NULL;
  141.         }
  142.         else
  143.         {
  144.                 inode->next = p->next;
  145.                 p->next = inode;
  146.         }
  147.         hnode->clenth++;
  148. }

  150. void delnode(int postion,Hnodep hnode) //delete elem at give postion
  151. {
  152.         Nodep p1; //delete postion-1 p
  153.         Nodep p2; //delete postion p

  155.         if(postion == 1)
  156.         {
  157.                 p2 = hnode->headp->next;
  158.                 hnode->headp->next = hnode->headp->next->next;
  159.                 free(p2);
  160.         }
  161.         else
  162.         {
  163.                 p1=getelemp(hnode,postion-1);//find before delete node postion
  164.                 p2 = p1->next;
  165.                 p1->next = p1->next->next;
  166.                 free(p2);
  167.         }
  168.         hnode->clenth--;
  169. }


點選(此處)摺疊或開啟

  1. main 函式：
  2. #include<iostream>
  3. #include<stdio.h>
  4. #include<stdlib.h>


  7. typedef unsigned int uint;
  8. typedef int Etype;
  9. typedef int datatype;

  11. typedef struct node
  12. {

  14.         datatype data;
  15.         struct node *next;
  16. } Node,*Nodep;

  18. typedef struct hnode
  19. {

  21.         int clenth;
  22.         Nodep headp;
  23. } Hnode,*Hnodep;


  26. typedef struct sqlist
  27. {

  29.         Etype* elem; //pointer of sqlist base address
  30.         uint length; //current length of elem
  31.         uint m_size; //
  32. } SQLIST;

  34. void initchain(Hnodep hnode,int n);
  35. void initchain(Hnodep hnode,const SQLIST* sqdata);
  36. void viewchain(Hnodep hnode);
  37. void view(SQLIST* inlist);
  38. void delsqldel(SQLIST* inlist,uint postion);
  39. void initsqlist(SQLIST* inlist);
  40. void initsqlinsert(SQLIST* inlist,Etype ielem,uint postion);
  41. void getelem(Hnodep hnode,int postion);
  42. void addnode(Nodep inode,int postion,const Hnodep hnode);
  43. void delnode(int postion,Hnodep hnode);


  46. int main(void)
  47. {
  48.         SQLIST a;
  49.         Hnode chd1;
  50.         Nodep newnode = (Nodep)malloc(sizeof(Node));
  51.         newnode->data=50;
  52.         newnode->next=NULL;
  53.         initsqlist(&a);
  54.         printf("insert 5 values use seq mode\n");
  55.         initsqlinsert(&a,5,1);
  56.         initsqlinsert(&a,10,1);
  57.         initsqlinsert(&a,15,1);
  58.         initsqlinsert(&a,20,1);
  59.         initsqlinsert(&a,25,1);
  60.         view(&a);
  61.         printf("\n\ninit chain use seq arrary\n");
  62.         initchain(&chd1,&a);
  63.         viewchain(&chd1);
  64.         printf("\n\nview one node at postion 3\n");
  65.         getelem(&chd1,3);
  66.     printf("\n\nadd one node after node 2\n");
  67.         addnode(newnode,2,&chd1);
  68.         viewchain(&chd1);
  69.         printf("\n\nadd one node at postion 2\n");
  70.         delnode(2,&chd1);
  71.         viewchain(&chd1);
  72.         return 0;
  73. }


編譯：
g++ main.cpp chain.cpp sqlist.cpp  -W
執行：
gaopeng@bogon:~/datas/part2/chain$ ./a.out 
insert 5 values use seq mode
node:0 values is:25 data length:5 max_size:10 
node:1 values is:20 data length:5 max_size:10 
node:2 values is:15 data length:5 max_size:10 
node:3 values is:10 data length:5 max_size:10 
node:4 values is:5 data length:5 max_size:10 

init chain use seq arrary
Max chain length is:5
node:1 values is: 25
node:2 values is: 5
node:3 values is: 10
node:4 values is: 15
node:5 values is: 20

view one node at postion 3
node 3 values is 10

add one node after node 2
Max chain length is:6
node:1 values is: 25
node:2 values is: 5
node:3 values is: 50
node:4 values is: 10
node:5 values is: 15
node:6 values is: 20

add one node at postion 2
Max chain length is:5
node:1 values is: 25
node:2 values is: 50
node:3 values is: 10
node:4 values is: 15
node:5 values is: 20

可以看到我初始化的連結串列為 25 5 10 15 20 檢視第三個元素為 10 在位置2後面插入一個元素50 變為
了 25 5 50 10 15 20 刪除位置2元素變為了 25  50 10 15 20 


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

相關文章