C/C++中对链表操作的理解实例分析
鏈表概述
鏈表是一種常見的重要的數據結構。它是動態地進行存儲分配的一種結構。它可以根據需要開辟內存單元。鏈表有一個“頭指針”變量，以head表示，它存放一個地址。該地址指向一個元素。鏈表中每一個元素稱為“結點”，每個結點都應包括兩個部分：一為用戶需要用的實際數據，二為下一個結點的地址。因此，head指向第一個元素：第一個元素又指向第二個元素；……，直到最后一個元素，該元素不再指向其它元素，它稱為“表尾”，它的地址部分放一個“NULL”（表示“空地址”），鏈表到此結束。
??????? 鏈表的各類操作包括：學習單向鏈表的創建、刪除、? 插入（無序、有序）、輸出、? 排序（選擇、插入、冒泡）、反序等等。
?????? 單向鏈表的圖示：
?????? ---->[NULL]
????? head
????? 圖1：空鏈表
?????? ---->[p1]---->[p2]...---->[pn]---->[NULL]
????? head?? p1->next? p2->next?? pn->next
????? 圖2：有N個節點的鏈表
????? 創建n個節點的鏈表的函數為：
?
1 #include "stdlib.h" 2 #include "stdio.h" 3 4 #define NULL 0 5 #define LEN sizeof(struct student) 6 7 struct student 8 { 9 int num; //學號 10 float score; //分數，其他信息可以繼續在下面增加字段 11 struct student *next; //指向下一節點的指針 12 }; 13 14 int n; //節點總數 15 /* 16 ========================== 17 功能：創建n個節點的鏈表 18 返回：指向鏈表表頭的指針 19 ========================== 20 */ 21 struct student *Create() 22 { 23 struct student *head; //頭節點 24 struct student *p1 = NULL; //p1保存創建的新節點的地址 25 struct student *p2 = NULL; //p2保存原鏈表最后一個節點的地址 26 27 n = 0; //創建前鏈表的節點總數為0：空鏈表 28 p1 = (struct student *) malloc (LEN); //開辟一個新節點 29 p2 = p1; //如果節點開辟成功，則p2先把它的指針保存下來以備后用 30 31 if(p1==NULL) //節點開辟不成功 32 { 33 printf ("\nCann't create it, try it again in a moment!\n"); 34 return NULL; 35 } 36 else //節點開辟成功 37 { 38 head = NULL; //開始head指向NULL 39 printf ("Please input %d node -- num,score: ", n + 1); 40 scanf ("%d %f", &(p1->num), &(p1->score)); //錄入數據 41 } 42 while(p1->num != 0) //只要學號不為0，就繼續錄入下一個節點 43 { 44 n += 1; //節點總數增加1個 45 if(n == 1) //如果節點總數是1，則head指向剛創建的節點p1 46 { 47 head = p1; 48 p2->next = NULL; //此時的p2就是p1,也就是p1->next指向NULL。 49 } 50 else 51 { 52 p2->next = p1; //指向上次下面剛剛開辟的新節點 53 } 54 55 p2 = p1; //把p1的地址給p2保留，然后p1產生新的節點 56 57 p1 = (struct student *) malloc (LEN); 58 printf ("Please input %d node -- num,score: ", n + 1); 59 scanf ("%d %f", &(p1->num), &(p1->score)); 60 } 61 p2->next = NULL; //此句就是根據單向鏈表的最后一個節點要指向NULL 62 63 free(p1); //p1->num為0的時候跳出了while循環，并且釋放p1 64 p1 = NULL; //特別不要忘記把釋放的變量清空置為NULL,否則就變成"野指針"，即地址不確定的指針 65 return head; //返回創建鏈表的頭指針 66 }?
輸出鏈表中節點的函數為：
1 /* 2 =========================== 3 功能：輸出節點 4 返回： void 5 =========================== 6 */ 7 void Print(struct student *head) 8 { 9 struct student *p; 10 printf ("\nNow , These %d records are:\n", n); 11 p = head; 12 if(head != NULL) //只要不是空鏈表，就輸出鏈表中所有節點 13 { 14 printf("head is %o\n", head); //輸出頭指針指向的地址 15 do 16 { 17 /* 18 輸出相應的值：當前節點地址、各字段值、當前節點的下一節點地址。 19 這樣輸出便于讀者形象看到一個單向鏈表在計算機中的存儲結構，和我們 20 設計的圖示是一模一樣的。 21 */ 22 printf ("%o %d %5.1f %o\n", p, p->num, p->score, p->next); 23 p = p->next; //移到下一個節點 24 } 25 while (p != NULL); 26 } 27 }/* 28 =========================== 29 功能：輸出節點 30 返回： void 31 =========================== 32 */ 33 void Print(struct student *head) 34 { 35 struct student *p; 36 printf ("\nNow , These %d records are:\n", n); 37 p = head; 38 if(head != NULL) //只要不是空鏈表，就輸出鏈表中所有節點 39 { 40 printf("head is %o\n", head); //輸出頭指針指向的地址 41 do 42 { 43 /* 44 輸出相應的值：當前節點地址、各字段值、當前節點的下一節點地址。 45 這樣輸出便于讀者形象看到一個單向鏈表在計算機中的存儲結構，和我們 46 設計的圖示是一模一樣的。 47 */ 48 printf ("%o %d %5.1f %o\n", p, p->num, p->score, p->next); 49 p = p->next; //移到下一個節點 50 } 51 while (p != NULL); 52 } 53 }單向鏈表的刪除圖示：
?????? ---->[NULL]
?????? head
?????? 圖3：空鏈表
????? 從圖3可知，空鏈表顯然不能刪除
????? ---->[1]---->[2]...---->[n]---->[NULL]（原鏈表）
????? head?? 1->next? 2->next?? n->next
????? ---->[2]...---->[n]---->[NULL]（刪除后鏈表）
????? head?? 2->next?? n->next
????? 圖4：有N個節點的鏈表，刪除第一個節點
????? 結合原鏈表和刪除后的鏈表，就很容易寫出相應的代碼。操作方法如下：
????? 1、你要明白head就是第1個節點，head->next就是第2個節點；
?????? 2、刪除后head指向第2個節點，就是讓head=head->next,OK這樣就行了。
?????? ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（原鏈表）
?????? head?? 1->next? 2->next? 3->next?? n->next
?????? ---->[1]---->[3]...---->[n]---->[NULL]（刪除后鏈表）
????? head?? 1->next? 3->next?? n->next
????? 圖5：有N個節點的鏈表，刪除中間一個（這里圖示刪除第2個）
????? 結合原鏈表和刪除后的鏈表，就很容易寫出相應的代碼。操作方法如下：
????? 1、你要明白head就是第1個節點，1->next就是第2個節點，2->next就是第3個節點；
??????2、刪除后2，1指向第3個節點，就是讓1->next=2->next。
????? 刪除指定學號的節點的函數為：
?
1 /* 2 ========================== 3 功能：刪除指定節點 4 (此例中是刪除指定學號的節點) 5 返回：指向鏈表表頭的指針 6 ========================== 7 */ 8 struct student *Del (struct student *head, int num) 9 { 10 struct student *p1; //p1保存當前需要檢查的節點的地址 11 struct student *p2; //p2保存當前檢查過的節點的地址 12 if (head == NULL) //是空鏈表（結合圖3理解） 13 { 14 printf ("\nList is null!\n"); 15 return head; 16 } 17 18 //定位要刪除的節點 19 p1 = head; 20 while (p1->num != num && p1->next != NULL) //p1指向的節點不是所要查找的，并且它不是最后一個節點，就繼續往下找 21 { 22 p2 = p1; //保存當前節點的地址 23 p1 = p1->next; //后移一個節點 24 } 25 26 if(p1->num==num) //找到了。（結合圖4、5理解） 27 { 28 if (p1 == head) //如果要刪除的節點是第一個節點 29 { 30 head = p1->next; //頭指針指向第一個節點的后一個節點，也就是第二個節點。這樣第一個節點就不在鏈表中，即刪除 31 } 32 else //如果是其它節點，則讓原來指向當前節點的指針，指向它的下一個節點，完成刪除 33 { 34 p2->next = p1->next; 35 } 36 37 free (p1); //釋放當前節點 38 p1 = NULL; 39 printf ("\ndelete %ld success!\n", num); 40 n -= 1; //節點總數減1個 41 } 42 else //沒有找到 43 { 44 printf ("\n%ld not been found!\n", num); 45 } 46 47 return head; 48 }?
單向鏈表的插入圖示：
?????? ---->[NULL]（原鏈表）
????? head
????? ---->[1]---->[NULL]（插入后的鏈表）
????? head?? 1->next
????? 圖7 空鏈表插入一個節點
????? 結合原鏈表和插入后的鏈表，就很容易寫出相應的代碼。操作方法如下：
???? 1、你要明白空鏈表head指向NULL就是head=NULL；
???? 2、插入后head指向第1個節點，就是讓head=1,1->next=NULL,OK這樣就行了。
???? ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（原鏈表）
???? head?? 1->next? 2->next? 3->next?? n->next
???? ---->[1]---->[2]---->[x]---->[3]...---->[n]---->[NULL]（插入后的鏈表）
???? head?? 1->next? 2->next? x->next? 3->next?? n->next
???? 圖8：有N個節點的鏈表，插入一個節點（這里圖示插入第2個后面）
???? 結合原鏈表和插入后的鏈表，就很容易寫出相應的代碼。操作方法如下：
??? 1、你要明白原1->next就是節點2，2->next就是節點3；
??? 2、插入后x指向第3個節點,2指向x，就是讓x->next=2->next,1->next=x。
??? 插入指定節點的后面的函數為：
1 /* 2 ========================== 3 功能：插入指定節點的后面 4 (此例中是指定學號的節點) 5 返回：指向鏈表表頭的指針 6 ========================== 7 */ 8 struct student *Insert (struct student *head, int num, struct student *node) 9 { 10 struct student *p1; //p1保存當前需要檢查的節點的地址 11 if (head == NULL) //（結合圖示7理解） 12 { 13 head = node; 14 node->next = NULL; 15 n += 1; 16 return head; 17 } 18 19 p1 = head; 20 while(p1->num != num && p1->next != NULL) //p1指向的節點不是所要查找的，并且它不是最后一個節點，繼續往下找 21 { 22 p1 = p1->next; //后移一個節點 23 } 24 25 if (p1->num==num) //找到了（結合圖示8理解） 26 { 27 node->next = p1->next; //顯然node的下一節點是原p1的next 28 p1->next = node; //插入后，原p1的下一節點就是要插入的node 29 n += 1; //節點總數增加1個 30 } 31 else 32 { 33 printf ("\n%ld not been found!\n", num); 34 } 35 return head; 36 }單向鏈表的反序圖示：
?????? ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（原鏈表）
?????? head?? 1->next? 2->next? 3->next?? n->next
????? [NULL]<----[1]<----[2]<----[3]<----...[n]<----（反序后的鏈表）
?????????????? ?1->next? 2->next? 3->next?? n->next? head
????????? 圖9：有N個節點的鏈表反序
????????? 結合原鏈表和插入后的鏈表，就很容易寫出相應的代碼。操作方法如下：
? ??????? 1、我們需要一個讀原鏈表的指針p2,存反序鏈表的p1=NULL（剛好最后一個節點的next為NULL）,還有一個臨時存儲變量p；
????????? 2、p2在原鏈表中讀出一個節點，我們就把它放到p1中，p就是用來處理節點放置順序的問題；
???????? ?3、比如，現在我們取得一個2,為了我們繼續往下取節點，我們必須保存它的next值，由原鏈表可知p=2->next;
????????? 4、然后由反序后的鏈表可知，反序后2->next要指向1，則2->next=1;
??????????5、好了，現在已經反序一個節點，接著處理下一個節點就需要保存此時的信息：
??????????p1變成剛剛加入的2，即p1=2;p2要變成它的下一節點，就是上面我們保存的p,即p2=p。
????????? 反序鏈表的函數為：
1 /* 2 ========================== 3 功能：反序節點 4 (鏈表的頭變成鏈表的尾，鏈表的尾變成頭) 5 返回：指向鏈表表頭的指針 6 ========================== 7 */ 8 9 struct student *Reverse (struct student *head) 10 { 11 struct student *p; //臨時存儲 12 struct student *p1; //存儲返回結果 13 struct student *p2; //源結果節點一個一個取 14 15 p1 = NULL; //開始顛倒時，已顛倒的部分為空 16 p2 = head; //p2指向鏈表的頭節點 17 while(p2 != NULL) 18 { 19 p = p2->next; 20 p2->next = p1; 21 p1 = p2; 22 p2 = p; 23 } 24 head = p1; 25 return head; 26 }? 對鏈表進行選擇排序的基本思想就是反復從還未排好序的那些節點中，選出鍵值（就是用它排序的字段，我們取學號num為鍵值）最小的節點，依次重新組合成一個鏈表。
???????? 我認為寫鏈表這類程序，關鍵是理解：head存儲的是第一個節點的地址，head->next存儲的是第二個節點的地址；任意一個節點p的地址，只能通過它前一個節點的next來求得。
??????? 單向鏈表的選擇排序圖示：
???????? ---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原鏈表）
???????? head?? 1->next? 3->next? 2->next?? n->next
???????? ---->[NULL]（空鏈表）
??????? first
??????? tail
???????? ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后鏈表）
???????? first?? 1->next? 2->next? 3->next?? tail->next
???????? 圖10：有N個節點的鏈表選擇排序
??????? 1、先在原鏈表中找最小的，找到一個后就把它放到另一個空的鏈表中；
??????? 2、空鏈表中安放第一個進來的節點，產生一個有序鏈表,并且讓它在原鏈表中分離出來（此時要注意原鏈表中出來的是第一個節點還是中間其它節點）；
??????? 3、繼續在原鏈表中找下一個最小的，找到后把它放入有序鏈表的尾指針的next,然后它變成其尾指針；
????????對鏈表進行選擇排序的函數為：
1 /* 2 ========================== 3 功能：選擇排序(由小到大) 4 返回：指向鏈表表頭的指針 5 ========================== 6 */ 7 struct student *SelectSort (struct student *head) 8 { 9 struct student *first; //排列后有序鏈的表頭指針 10 struct student *tail; //排列后有序鏈的表尾指針 11 struct student *p_min; //保留鍵值更小的節點的前驅節點的指針 12 struct student *min; //存儲最小節點 13 struct student *p; //當前比較的節點 14 15 first = NULL; 16 while(head != NULL) //在鏈表中找鍵值最小的節點 17 { 18 //注意：這里for語句就是體現選擇排序思想的地方 19 for (p = head, min = head; p->next != NULL; p = p->next) //循環遍歷鏈表中的節點，找出此時最小的節點 20 { 21 if (p->next->num < min->num) //找到一個比當前min小的節點 22 { 23 p_min = p; //保存找到節點的前驅節點：顯然p->next的前驅節點是p 24 min = p->next; //保存鍵值更小的節點 25 } 26 } 27 28 //上面for語句結束后，就要做兩件事；一是把它放入有序鏈表中；二是根據相應的條件判斷，安排它離開原來的鏈表 29 30 //第一件事 31 if (first == NULL) //如果有序鏈表目前還是一個空鏈表 32 { 33 first = min; //第一次找到鍵值最小的節點 34 tail = min; //注意：尾指針讓它指向最后的一個節點 35 } 36 else //有序鏈表中已經有節點 37 { 38 tail->next = min; //把剛找到的最小節點放到最后，即讓尾指針的next指向它 39 tail = min; //尾指針也要指向它 40 } 41 42 //第二件事 43 if (min == head) //如果找到的最小節點就是第一個節點 44 { 45 head = head->next; //顯然讓head指向原head->next,即第二個節點，就OK 46 } 47 else //如果不是第一個節點 48 { 49 p_min->next = min->next; //前次最小節點的next指向當前min的next,這樣就讓min離開了原鏈表 50 } 51 } 52 53 if (first != NULL) //循環結束得到有序鏈表first 54 { 55 tail->next = NULL; //單向鏈表的最后一個節點的next應該指向NULL 56 } 57 head = first; 58 return head; 59 }對鏈表進行直接插入排序的基本思想就是假設鏈表的前面n-1個節點是已經按鍵值（就是用它排序的字段，我們取學號num為鍵值）排好序的，對于節點n在這個序列中找插入位置，使得n插入后新序列仍然有序。按照這種思想，依次對鏈表從頭到尾執行一遍，就可以使無序鏈表變為有序鏈表。
???????? 單向鏈表的直接插入排序圖示：
???????? ---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原鏈表）
??????? head?? 1->next? 3->next? 2->next?? n->next
???????? ---->[1]---->[NULL]（從原鏈表中取第1個節點作為只有一個節點的有序鏈表）
??????? head
??????? 圖11
??????? ---->[3]---->[2]...---->[n]---->[NULL]（原鏈表剩下用于直接插入排序的節點）
??????? first?? 3->next? 2->next?? n->next
??????? 圖12
??????? ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后鏈表）
??????? head?? 1->next? 2->next? 3->next?? n->next
??????? 圖13：有N個節點的鏈表直接插入排序
?????? 1、先在原鏈表中以第一個節點為一個有序鏈表，其余節點為待定節點。
?????? 2、從圖12鏈表中取節點，到圖11鏈表中定位插入。
?????? 3、上面圖示雖說畫了兩條鏈表，其實只有一條鏈表。在排序中，實質只增加了一個用于指向剩下需要排序節點的頭指針first罷了。
?????? 這一點請讀者務必搞清楚，要不然就可能認為它和上面的選擇排序法一樣了。
?????? 對鏈表進行直接插入排序的函數為：
1 /* 2 ========================== 3 功能：直接插入排序(由小到大) 4 返回：指向鏈表表頭的指針 5 ========================== 6 */ 7 struct student *InsertSort (struct student *head) 8 { 9 struct student *first; //為原鏈表剩下用于直接插入排序的節點頭指針 10 struct student *t; //臨時指針變量：插入節點 11 struct student *p,*q; //臨時指針變量 12 13 first = head->next; //原鏈表剩下用于直接插入排序的節點鏈表：可根據圖12來理解 14 head->next = NULL; //只含有一個節點的鏈表的有序鏈表：可根據圖11來理解 15 16 while(first != NULL) //遍歷剩下無序的鏈表 17 { 18 //注意：這里for語句就是體現直接插入排序思想的地方 19 for (t = first, q = head; ((q != NULL) && (q->num < t->num)); p = q, q = q->next); //無序節點在有序鏈表中找插入的位置 20 21 //退出for循環，就是找到了插入的位置，應該將t節點插入到p節點之后，q節點之前 22 //注意：按道理來說，這句話可以放到下面注釋了的那個位置也應該對的，但是就是不能。原因：你若理解了上面的第3條，就知道了 23 //下面的插入就是將t節點即是first節點插入到p節點之后，已經改變了first節點，所以first節點應該在被修改之前往后移動，不能放到下面注釋的位置上去 24 first = first->next; //無序鏈表中的節點離開，以便它插入到有序鏈表中 25 26 if (q == head) //插在第一個節點之前 27 { 28 head = t; 29 } 30 else //p是q的前驅 31 { 32 p->next = t; 33 } 34 t->next = q; //完成插入動作 35 //first = first->next; 36 } 37 return head; 38 }?? 對鏈表進行冒泡排序的基本思想就是對當前還未排好序的范圍內的全部節點，自上而下對相鄰的兩個節點依次進行比較和調整，讓鍵值（就是用它排?序的字段，我們取學號num為鍵值）較大的節點往下沉，鍵值較小的往上冒。即：每當兩相鄰的節點比較后發現它們的排序與排序要求相反時，就將它們互換。
??????? 單向鏈表的冒泡排序圖示：
??????? ---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原鏈表）
?????? head?? 1->next? 3->next? 2->next?? n->next
?????? ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后鏈表）
?????? head?? 1->next? 2->next? 3->next?? n->next
?????? 圖14：有N個節點的鏈表冒泡排序
????? 任意兩個相鄰節點p、q位置互換圖示:
????? 假設p1->next指向p，那么顯然p1->next->next就指向q,
????? p1->next->next->next就指向q的后繼節點，我們用p2保存
????? p1->next->next指針。即：p2=p1->next->next，則有：
?????? [? ]---->[p]---------->[q]---->[? ]（排序前）
?????? p1->next? p1->next->next? p2->next
?????? 圖15
?????? [? ]---->[q]---------->[p]---->[? ]（排序后）
???????圖16
????? 1、排序后q節點指向p節點，在調整指向之前，我們要保存原p的指向節點地址，即：p2=p1->next->next；
????? 2、順著這一步一步往下推,排序后圖16中p1->next->next要指的是p2->next,所以p1->next->next=p2->next;
????? 3、在圖15中p2->next原是q發出來的指向，排序后圖16中q的指向要變為指向p的，而原來p1->next是指向p的，所以p2->next=p1->next;
????? 4、在圖15中p1->next原是指向p的，排序后圖16中p1->next要指向q,原來p1->next->next（即p2)是指向q的，所以p1->next=p2;
????? 5、至此，我們完成了相鄰兩節點的順序交換。
????? 6、下面的程序描述改進了一點就是記錄了每次最后一次節點下沉的位置，這樣我們不必每次都從頭到尾的掃描，只需要掃描到記錄點為止。?因為后面的都已經是排好序的了。
?????? 對鏈表進行冒泡排序的函數為：
1 /* 2 ========================== 3 功能：冒泡排序(由小到大) 4 返回：指向鏈表表頭的指針 5 ========================== 6 */ 7 struct student *BubbleSort (struct student *head) 8 { 9 struct student *endpt; //控制循環比較 10 struct student *p; //臨時指針變量 11 struct student *p1,*p2; 12 13 p1 = (struct student *) malloc (LEN); 14 p1->next = head; //注意理解：我們增加一個節點，放在第一個節點的前面，主要是為了便于比較。因為第一個節點沒有前驅，我們不能交換地址 15 head = p1; //讓head指向p1節點，排序完成后，我們再把p1節點釋放掉 16 17 for (endpt = NULL; endpt != head; endpt = p) //結合第6點理解 18 { 19 for (p = p1 = head; p1->next->next != endpt; p1 = p1->next) 20 { 21 if (p1->next->num > p1->next->next->num) //如果前面的節點鍵值比后面節點的鍵值大，則交換 22 { 23 p2 = p1->next->next; //結合第1點理解 24 p1->next->next = p2->next; //結合第2點理解 25 p2->next = p1->next; //結合第3點理解 26 p1->next = p2; //結合第4點理解 27 p = p1->next->next; //結合第6點理解 28 } 29 } 30 } 31 32 p1 = head; //把p1的信息去掉 33 head = head->next; //讓head指向排序后的第一個節點 34 free (p1); //釋放p1 35 p1 = NULL; //p1置為NULL，保證不產生“野指針”，即地址不確定的指針變量 36 37 return head; 38 }有序鏈表插入節點示意圖：
??????? ---->[NULL]（空有序鏈表）
??????? head
?????? 圖18：空有序鏈表（空有序鏈表好解決，直接讓head指向它就是了。）
?????? 以下討論不為空的有序鏈表。
??????? ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（有序鏈表）
??????? head?? 1->next? 2->next? 3->next?? n->next
?????? 圖18：有N個節點的有序鏈表
?????? 插入node節點的位置有兩種情況：一是第一個節點前，二是其它節點前或后。
?????? ---->[node]---->[1]---->[2]---->[3]...---->[n]---->[NULL]
?????? head? node->next? 1->next? 2->next? 3->next?? n->next
???????圖19：node節點插在第一個節點前
?????? ---->[1]---->[2]---->[3]...---->[node]...---->[n]---->[NULL]
????? head?? 1->next? 2->next? 3->next??? node->next? n->next
?????? 插入有序鏈表的函數為：
?
1 /* 2 ========================== 3 功能：插入有序鏈表的某個節點的后面(從小到大) 4 返回：指向鏈表表頭的指針 5 ========================== 6 */ 7 8 struct student *SortInsert (struct student *head, struct student *node) 9 { 10 struct student *p; //p保存當前需要檢查的節點的地址 11 struct student *t; //臨時指針變量 12 13 if (head == NULL) //處理空的有序鏈表 14 { 15 head = node; 16 node->next = NULL; 17 n += 1; //插入完畢，節點總數加 18 return head; 19 } 20 21 p = head; //有序鏈表不為空 22 while(p->num < node->num && p != NULL) //p指向的節點的學號比插入節點的學號小，并且它不等于NULL 23 { 24 t = p; //保存當前節點的前驅，以便后面判斷后處理 25 p = p->next; //后移一個節點 26 } 27 28 if (p == head) //剛好插入第一個節點之前 29 { 30 node->next = p; 31 head = node; 32 } 33 else //插入其它節點之后 34 { 35 t->next = node; //把node節點加進去 36 node->next = p; 37 } 38 n += 1; //插入完畢，節點總數加1 39 40 return head; 41 }?
綜上所述，鏈表的各類操作函數的完整代碼如下：
?
1 #include "stdlib.h" 2 #include "stdio.h" 3 4 #define NULL 0 5 #define LEN sizeof(struct student) 6 7 struct student 8 { 9 int num; //學號 10 float score; //分數，其他信息可以繼續在下面增加字段 11 struct student *next; //指向下一節點的指針 12 }; 13 14 int n; //節點總數 15 /* 16 ========================== 17 功能：創建n個節點的鏈表 18 返回：指向鏈表表頭的指針 19 ========================== 20 */ 21 struct student *Create() 22 { 23 struct student *head; //頭節點 24 struct student *p1 = NULL; //p1保存創建的新節點的地址 25 struct student *p2 = NULL; //p2保存原鏈表最后一個節點的地址 26 27 n = 0; //創建前鏈表的節點總數為0：空鏈表 28 p1 = (struct student *) malloc (LEN); //開辟一個新節點 29 p2 = p1; //如果節點開辟成功，則p2先把它的指針保存下來以備后用 30 31 if(p1==NULL) //節點開辟不成功 32 { 33 printf ("\nCann't create it, try it again in a moment!\n"); 34 return NULL; 35 } 36 else //節點開辟成功 37 { 38 head = NULL; //開始head指向NULL 39 printf ("Please input %d node -- num,score: ", n + 1); 40 scanf ("%d %f", &(p1->num), &(p1->score)); //錄入數據 41 } 42 while(p1->num != 0) //只要學號不為0，就繼續錄入下一個節點 43 { 44 n += 1; //節點總數增加1個 45 if(n == 1) //如果節點總數是1，則head指向剛創建的節點p1 46 { 47 head = p1; 48 p2->next = NULL; //此時的p2就是p1,也就是p1->next指向NULL。 49 } 50 else 51 { 52 p2->next = p1; //指向上次下面剛剛開辟的新節點 53 } 54 55 p2 = p1; //把p1的地址給p2保留，然后p1產生新的節點 56 57 p1 = (struct student *) malloc (LEN); 58 printf ("Please input %d node -- num,score: ", n + 1); 59 scanf ("%d %f", &(p1->num), &(p1->score)); 60 } 61 p2->next = NULL; //此句就是根據單向鏈表的最后一個節點要指向NULL 62 63 free(p1); //p1->num為0的時候跳出了while循環，并且釋放p1 64 p1 = NULL; //特別不要忘記把釋放的變量清空置為NULL,否則就變成"野指針"，即地址不確定的指針 65 return head; //返回創建鏈表的頭指針 66 } 67 68 69 /* 70 =========================== 71 功能：輸出節點 72 返回： void 73 =========================== 74 */ 75 void Print(struct student *head) 76 { 77 struct student *p; 78 printf ("\nNow , These %d records are:\n", n); 79 p = head; 80 if(head != NULL) //只要不是空鏈表，就輸出鏈表中所有節點 81 { 82 printf("head is %o\n", head); //輸出頭指針指向的地址 83 do 84 { 85 /* 86 輸出相應的值：當前節點地址、各字段值、當前節點的下一節點地址。 87 這樣輸出便于讀者形象看到一個單向鏈表在計算機中的存儲結構，和我們 88 設計的圖示是一模一樣的。 89 */ 90 printf ("%o %d %5.1f %o\n", p, p->num, p->score, p->next); 91 p = p->next; //移到下一個節點 92 } 93 while (p != NULL); 94 } 95 } 96 97 /* 98 ========================== 99 功能：刪除指定節點 100 (此例中是刪除指定學號的節點) 101 返回：指向鏈表表頭的指針 102 ========================== 103 */ 104 struct student *Del (struct student *head, int num) 105 { 106 struct student *p1; //p1保存當前需要檢查的節點的地址 107 struct student *p2; //p2保存當前檢查過的節點的地址 108 if (head == NULL) //是空鏈表（結合圖3理解） 109 { 110 printf ("\nList is null!\n"); 111 return head; 112 } 113 114 //定位要刪除的節點 115 p1 = head; 116 while (p1->num != num && p1->next != NULL) //p1指向的節點不是所要查找的，并且它不是最后一個節點，就繼續往下找 117 { 118 p2 = p1; //保存當前節點的地址 119 p1 = p1->next; //后移一個節點 120 } 121 122 if(p1->num==num) //找到了。（結合圖4、5理解） 123 { 124 if (p1 == head) //如果要刪除的節點是第一個節點 125 { 126 head = p1->next; //頭指針指向第一個節點的后一個節點，也就是第二個節點。這樣第一個節點就不在鏈表中，即刪除 127 } 128 else //如果是其它節點，則讓原來指向當前節點的指針，指向它的下一個節點，完成刪除 129 { 130 p2->next = p1->next; 131 } 132 133 free (p1); //釋放當前節點 134 p1 = NULL; 135 printf ("\ndelete %ld success!\n", num); 136 n -= 1; //節點總數減1個 137 } 138 else //沒有找到 139 { 140 printf ("\n%ld not been found!\n", num); 141 } 142 143 return head; 144 } 145 146 //銷毀鏈表 147 void DestroyList(struct student *head) 148 { 149 struct student *p; 150 if(head==NULL) 151 return 0; 152 while(head) 153 { 154 p=head->next; 155 free(head); 156 head=p; 157 } 158 return 1; 159 } 160 161 /* 162 ========================== 163 功能：插入指定節點的后面 164 (此例中是指定學號的節點) 165 返回：指向鏈表表頭的指針 166 ========================== 167 */ 168 struct student *Insert (struct student *head, int num, struct student *node) 169 { 170 struct student *p1; //p1保存當前需要檢查的節點的地址 171 if (head == NULL) //（結合圖示7理解） 172 { 173 head = node; 174 node->next = NULL; 175 n += 1; 176 return head; 177 } 178 179 p1 = head; 180 while(p1->num != num && p1->next != NULL) //p1指向的節點不是所要查找的，并且它不是最后一個節點，繼續往下找 181 { 182 p1 = p1->next; //后移一個節點 183 } 184 185 if (p1->num==num) //找到了（結合圖示8理解） 186 { 187 node->next = p1->next; //顯然node的下一節點是原p1的next 188 p1->next = node; //插入后，原p1的下一節點就是要插入的node 189 n += 1; //節點總數增加1個 190 } 191 else 192 { 193 printf ("\n%ld not been found!\n", num); 194 } 195 return head; 196 } 197 198 /* 199 ========================== 200 功能：反序節點 201 (鏈表的頭變成鏈表的尾，鏈表的尾變成頭) 202 返回：指向鏈表表頭的指針 203 ========================== 204 */ 205 206 struct student *Reverse (struct student *head) 207 { 208 struct student *p; //臨時存儲 209 struct student *p1; //存儲返回結果 210 struct student *p2; //源結果節點一個一個取 211 212 p1 = NULL; //開始顛倒時，已顛倒的部分為空 213 p2 = head; //p2指向鏈表的頭節點 214 while(p2 != NULL) 215 { 216 p = p2->next; 217 p2->next = p1; 218 p1 = p2; 219 p2 = p; 220 } 221 head = p1; 222 return head; 223 } 224 /* 225 ========================== 226 功能：選擇排序(由小到大) 227 返回：指向鏈表表頭的指針 228 ========================== 229 */ 230 struct student *SelectSort (struct student *head) 231 { 232 struct student *first; //排列后有序鏈的表頭指針 233 struct student *tail; //排列后有序鏈的表尾指針 234 struct student *p_min; //保留鍵值更小的節點的前驅節點的指針 235 struct student *min; //存儲最小節點 236 struct student *p; //當前比較的節點 237 238 first = NULL; 239 while(head != NULL) //在鏈表中找鍵值最小的節點 240 { 241 //注意：這里for語句就是體現選擇排序思想的地方 242 for (p = head, min = head; p->next != NULL; p = p->next) //循環遍歷鏈表中的節點，找出此時最小的節點 243 { 244 if (p->next->num < min->num) //找到一個比當前min小的節點 245 { 246 p_min = p; //保存找到節點的前驅節點：顯然p->next的前驅節點是p 247 min = p->next; //保存鍵值更小的節點 248 } 249 } 250 251 //上面for語句結束后，就要做兩件事；一是把它放入有序鏈表中；二是根據相應的條件判斷，安排它離開原來的鏈表 252 253 //第一件事 254 if (first == NULL) //如果有序鏈表目前還是一個空鏈表 255 { 256 first = min; //第一次找到鍵值最小的節點 257 tail = min; //注意：尾指針讓它指向最后的一個節點 258 } 259 else //有序鏈表中已經有節點 260 { 261 tail->next = min; //把剛找到的最小節點放到最后，即讓尾指針的next指向它 262 tail = min; //尾指針也要指向它 263 } 264 265 //第二件事 266 if (min == head) //如果找到的最小節點就是第一個節點 267 { 268 head = head->next; //顯然讓head指向原head->next,即第二個節點，就OK 269 } 270 else //如果不是第一個節點 271 { 272 p_min->next = min->next; //前次最小節點的next指向當前min的next,這樣就讓min離開了原鏈表 273 } 274 } 275 276 if (first != NULL) //循環結束得到有序鏈表first 277 { 278 tail->next = NULL; //單向鏈表的最后一個節點的next應該指向NULL 279 } 280 head = first; 281 return head; 282 } 283 284 285 /* 286 ========================== 287 功能：直接插入排序(由小到大) 288 返回：指向鏈表表頭的指針 289 ========================== 290 */ 291 struct student *InsertSort (struct student *head) 292 { 293 struct student *first; //為原鏈表剩下用于直接插入排序的節點頭指針 294 struct student *t; //臨時指針變量：插入節點 295 struct student *p,*q; //臨時指針變量 296 297 first = head->next; //原鏈表剩下用于直接插入排序的節點鏈表：可根據圖12來理解 298 head->next = NULL; //只含有一個節點的鏈表的有序鏈表：可根據圖11來理解 299 300 while(first != NULL) //遍歷剩下無序的鏈表 301 { 302 //注意：這里for語句就是體現直接插入排序思想的地方 303 for (t = first, q = head; ((q != NULL) && (q->num < t->num)); p = q, q = q->next); //無序節點在有序鏈表中找插入的位置 304 305 //退出for循環，就是找到了插入的位置，應該將t節點插入到p節點之后，q節點之前 306 //注意：按道理來說，這句話可以放到下面注釋了的那個位置也應該對的，但是就是不能。原因：你若理解了上面的第3條，就知道了 307 //下面的插入就是將t節點即是first節點插入到p節點之后，已經改變了first節點，所以first節點應該在被修改之前往后移動，不能放到下面注釋的位置上去 308 first = first->next; //無序鏈表中的節點離開，以便它插入到有序鏈表中 309 310 if (q == head) //插在第一個節點之前 311 { 312 head = t; 313 } 314 else //p是q的前驅 315 { 316 p->next = t; 317 } 318 t->next = q; //完成插入動作 319 //first = first->next; 320 } 321 return head; 322 } 323 324 /* 325 ========================== 326 功能：冒泡排序(由小到大) 327 返回：指向鏈表表頭的指針 328 ========================== 329 */ 330 struct student *BubbleSort (struct student *head) 331 { 332 struct student *endpt; //控制循環比較 333 struct student *p; //臨時指針變量 334 struct student *p1,*p2; 335 336 p1 = (struct student *) malloc (LEN); 337 p1->next = head; //注意理解：我們增加一個節點，放在第一個節點的前面，主要是為了便于比較。因為第一個節點沒有前驅，我們不能交換地址 338 head = p1; //讓head指向p1節點，排序完成后，我們再把p1節點釋放掉 339 340 for (endpt = NULL; endpt != head; endpt = p) //結合第6點理解 341 { 342 for (p = p1 = head; p1->next->next != endpt; p1 = p1->next) 343 { 344 if (p1->next->num > p1->next->next->num) //如果前面的節點鍵值比后面節點的鍵值大，則交換 345 { 346 p2 = p1->next->next; //結合第1點理解 347 p1->next->next = p2->next; //結合第2點理解 348 p2->next = p1->next; //結合第3點理解 349 p1->next = p2; //結合第4點理解 350 p = p1->next->next; //結合第6點理解 351 } 352 } 353 } 354 355 p1 = head; //把p1的信息去掉 356 head = head->next; //讓head指向排序后的第一個節點 357 free (p1); //釋放p1 358 p1 = NULL; //p1置為NULL，保證不產生“野指針”，即地址不確定的指針變量 359 360 return head; 361 } 362 363 /* 364 ========================== 365 功能：插入有序鏈表的某個節點的后面(從小到大) 366 返回：指向鏈表表頭的指針 367 ========================== 368 */ 369 370 struct student *SortInsert (struct student *head, struct student *node) 371 { 372 struct student *p; //p保存當前需要檢查的節點的地址 373 struct student *t; //臨時指針變量 374 375 if (head == NULL) //處理空的有序鏈表 376 { 377 head = node; 378 node->next = NULL; 379 n += 1; //插入完畢，節點總數加 380 return head; 381 } 382 383 p = head; //有序鏈表不為空 384 while(p->num < node->num && p != NULL) //p指向的節點的學號比插入節點的學號小，并且它不等于NULL 385 { 386 t = p; //保存當前節點的前驅，以便后面判斷后處理 387 p = p->next; //后移一個節點 388 } 389 390 if (p == head) //剛好插入第一個節點之前 391 { 392 node->next = p; 393 head = node; 394 } 395 else //插入其它節點之后 396 { 397 t->next = node; //把node節點加進去 398 node->next = p; 399 } 400 n += 1; //插入完畢，節點總數加1 401 402 return head; 403 } 404 405 /* 406 以上函數的測試程序： 407 提示：根據測試函數的不同注釋相應的程序段，這也是一種測試方法。 408 */ 409 int main(void) 410 { 411 struct student *head; 412 struct student *stu; 413 int thenumber; 414 415 // 測試Create()、Print() 416 head = Create(); 417 Print(head); 418 419 //測試Del() 420 printf("\nWhich one delete: "); 421 scanf("%d",&thenumber); 422 head = Del(head,thenumber); 423 Print(head); 424 425 //測試Insert() 426 stu = (struct student *)malloc(LEN); 427 printf("\nPlease input insert node -- num,score: "); 428 scanf("%d %f",&stu->num,&stu->score); 429 printf("\nInsert behind num: "); 430 scanf("%d",&thenumber); 431 head = Insert(head,thenumber,stu); 432 Print(head); 433 434 //測試Reverse() 435 printf("\nReverse the LinkList: \n"); 436 head = Reverse(head); 437 Print(head); 438 439 //測試SelectSort() 440 printf("\nSelectSort the LinkList: \n"); 441 head = SelectSort(head); 442 Print(head); 443 444 //測試InsertSort() 445 printf("\nInsertSort the LinkList: \n"); 446 head = InsertSort(head); 447 Print(head); 448 449 //測試BubbleSort() 450 printf("\nBubbleSort the LinkList: \n"); 451 head = BubbleSort(head); 452 Print(head); 453 454 printf("\nSortInsert the LinkList: \n"); 455 //測試SortInsert():上面創建鏈表，輸入節點時請注意學號num從小到大的順序 456 stu = (struct student *)malloc(LEN); 457 printf("\nPlease input insert node -- num,score: "); 458 scanf("%d %f",&stu->num,&stu->score); 459 head = SortInsert(head,stu); 460 Print(head); 461 462 //銷毀鏈表 463 DestroyList(head); 464 465 printf ("\n"); 466 system ("pause"); 467 }?
總結
以上是生活随笔為你收集整理的C/C++中对链表操作的理解实例分析的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： [Leetcode][JAVA]第[29
- 下一篇： 调查：Java程序员最伤心，C++程序员