鏈表概述
鏈表是一種常見的重要的數據結構。它是動態地進行存儲分配的一種結構。它可以根據需要開辟內存單元。鏈表有一個“頭指針”變量，以head表示，它存放一個地址。該地址指向一個元素。鏈表中每一個元素稱為“結點”，每個結點都應包括兩個部分：一為用戶需要用的實際數據，二為下一個結點的地址。因此，head指向第一個元素：第一個元素又指向第二個元素；……，直到最后一個元素，該元素不再指向其它元素，它稱為“表尾”，它的地址部分放一個“NULL”（表示“空地址”），鏈表到此結束。鏈表的各類操作包括：學習單向鏈表的創建、刪除、插入（無序、有序）、輸出、排序（選擇、插入、冒泡）、反序等等。
創建n個節點的鏈表
#include "stdlib.h"
#include "stdio.h"
#define NULL 0
#define LEN sizeof(struct student)
struct student
{
int num; //學號
float score; //分數，其他信息可以繼續在下面增加字段
struct student *next; //指向下一節點的指針
};
int n; //節點總數
/*
==========================
功能：創建n個節點的鏈表
返回：指向鏈表表頭的指針
==========================
*/
struct student *Create()
{
struct student *head; //頭節點
struct student *p1 = NULL; //p1保存創建的新節點的地址
struct student *p2 = NULL; //p2保存原鏈表最后一個節點的地址
n = 0; //創建前鏈表的節點總數為0：空鏈表
p1 = (struct student *) malloc (LEN); //開辟一個新節點
p2 = p1; //如果節點開辟成功，則p2先把它的指針保存下來以備后用
if(p1==NULL) //節點開辟不成功
{
printf ("\nCann't create it, try it again in a moment!\n");
return NULL;
}
else //節點開辟成功
{
head = NULL; //開始head指向NULL
printf ("Please input %d node -- num,score: ", n + 1);
scanf ("%d %f", &(p1->num), &(p1->score)); //錄入數據
}
while(p1->num != 0) //只要學號不為0，就繼續錄入下一個節點
{
n += 1; //節點總數增加1個
if(n == 1) //如果節點總數是1，則head指向剛創建的節點p1
{
head = p1;
p2->next = NULL; //此時的p2就是p1,也就是p1->next指向NULL。
}
else
{
p2->next = p1; //指向上次下面剛剛開辟的新節點
}
p2 = p1; //把p1的地址給p2保留，然后p1產生新的節點
p1 = (struct student *) malloc (LEN);
printf ("Please input %d node -- num,score: ", n + 1);
scanf ("%d %f", &(p1->num), &(p1->score));
}
p2->next = NULL; //此句就是根據單向鏈表的最后一個節點要指向NULL
free(p1); //p1->num為0的時候跳出了while循環，並且釋放p1
p1 = NULL; //特別不要忘記把釋放的變量清空置為NULL,否則就變成"野指針"，即地址不確定的指針
return head; //返回創建鏈表的頭指針
}
輸出鏈表中節點
/*
===========================
功能：輸出節點
返回： void
===========================
*/
void Print(struct student *head)
{
struct student *p;
printf ("\nNow , These %d records are:\n", n);
p = head;
if(head != NULL) //只要不是空鏈表，就輸出鏈表中所有節點
{
printf("head is %o\n", head); //輸出頭指針指向的地址
do
{
/*
輸出相應的值：當前節點地址、各字段值、當前節點的下一節點地址。
這樣輸出便於讀者形象看到一個單向鏈表在計算機中的存儲結構，和我們
設計的圖示是一模一樣的。
*/
printf ("%o %d %5.1f %o\n", p, p->num, p->score, p->next);
p = p->next; //移到下一個節點
}
while (p != NULL);
}
}
刪除指定學號的節點
/*
==========================
功能：刪除指定節點
(此例中是刪除指定學號的節點)
返回：指向鏈表表頭的指針
==========================
*/
struct student *Del (struct student *head, int num)
{
struct student *p1; //p1保存當前需要檢查的節點的地址
struct student *p2; //p2保存當前檢查過的節點的地址
if (head == NULL) //是空鏈表（結合圖3理解）
{
printf ("\nList is null!\n");
return head;
}
//定位要刪除的節點
p1 = head;
while (p1->num != num && p1->next != NULL) //p1指向的節點不是所要查找的，並且它不是最后一個節點，就繼續往下找
{
p2 = p1; //保存當前節點的地址
p1 = p1->next; //后移一個節點
}
if(p1->num==num) //找到了。（結合圖4、5理解）
{
if (p1 == head) //如果要刪除的節點是第一個節點
{
head = p1->next; //頭指針指向第一個節點的后一個節點，也就是第二個節點。這樣第一個節點就不在鏈表中，即刪除
}
else //如果是其它節點，則讓原來指向當前節點的指針，指向它的下一個節點，完成刪除
{
p2->next = p1->next;
}
free (p1); //釋放當前節點
p1 = NULL;
printf ("\ndelete %ld success!\n", num);
n -= 1; //節點總數減1個
}
else //沒有找到
{
printf ("\n%ld not been found!\n", num);
}
return head;
}
插入指定節點的后面
/*
==========================
功能：插入指定節點的后面
(此例中是指定學號的節點)
返回：指向鏈表表頭的指針
==========================
*/
struct student *Insert (struct student *head, int num, struct student *node)
{
struct student *p1; //p1保存當前需要檢查的節點的地址
if (head == NULL) //（結合圖示7理解）
{
head = node;
node->next = NULL;
n += 1;
return head;
}
p1 = head;
while(p1->num != num && p1->next != NULL) //p1指向的節點不是所要查找的，並且它不是最后一個節點，繼續往下找
{
p1 = p1->next; //后移一個節點
}
if (p1->num==num) //找到了（結合圖示8理解）
{
node->next = p1->next; //顯然node的下一節點是原p1的next
p1->next = node; //插入后，原p1的下一節點就是要插入的node
n += 1; //節點總數增加1個
}
else
{
printf ("\n%ld not been found!\n", num);
}
return head;
}
反序鏈表
/*
==========================
功能：反序節點
(鏈表的頭變成鏈表的尾，鏈表的尾變成頭)
返回：指向鏈表表頭的指針
==========================
*/
struct student *Reverse (struct student *head)
{
struct student *p; //臨時存儲
struct student *p1; //存儲返回結果
struct student *p2; //源結果節點一個一個取
p1 = NULL; //開始顛倒時，已顛倒的部分為空
p2 = head; //p2指向鏈表的頭節點
while(p2 != NULL)
{
p = p2->next;
p2->next = p1;
p1 = p2;
p2 = p;
}
head = p1;
return head;
}
對鏈表進行選擇排序
/*
==========================
功能：選擇排序(由小到大)
返回：指向鏈表表頭的指針
==========================
*/
struct student *SelectSort (struct student *head)
{
struct student *first; //排列后有序鏈的表頭指針
struct student *tail; //排列后有序鏈的表尾指針
struct student *p_min; //保留鍵值更小的節點的前驅節點的指針
struct student *min; //存儲最小節點
struct student *p; //當前比較的節點
first = NULL;
while(head != NULL) //在鏈表中找鍵值最小的節點
{
//注意：這里for語句就是體現選擇排序思想的地方
for (p = head, min = head; p->next != NULL; p = p->next) //循環遍歷鏈表中的節點，找出此時最小的節點
{
if (p->next->num < min->num) //找到一個比當前min小的節點
{
p_min = p; //保存找到節點的前驅節點：顯然p->next的前驅節點是p
min = p->next; //保存鍵值更小的節點
}
}
//上面for語句結束后，就要做兩件事；一是把它放入有序鏈表中；二是根據相應的條件判斷，安排它離開原來的鏈表
//第一件事
if (first == NULL) //如果有序鏈表目前還是一個空鏈表
{
first = min; //第一次找到鍵值最小的節點
tail = min; //注意：尾指針讓它指向最后的一個節點
}
else //有序鏈表中已經有節點
{
tail->next = min; //把剛找到的最小節點放到最后，即讓尾指針的next指向它
tail = min; //尾指針也要指向它
}
//第二件事
if (min == head) //如果找到的最小節點就是第一個節點
{
head = head->next; //顯然讓head指向原head->next,即第二個節點，就OK
}
else //如果不是第一個節點
{
p_min->next = min->next; //前次最小節點的next指向當前min的next,這樣就讓min離開了原鏈表
}
}
if (first != NULL) //循環結束得到有序鏈表first
{
tail->next = NULL; //單向鏈表的最后一個節點的next應該指向NULL
}
head = first;
return head;
}
對鏈表進行冒泡排序
/*
==========================
功能：冒泡排序(由小到大)
返回：指向鏈表表頭的指針
==========================
*/
struct student *BubbleSort (struct student *head)
{
struct student *endpt; //控制循環比較
struct student *p; //臨時指針變量
struct student *p1,*p2;
p1 = (struct student *) malloc (LEN);
p1->next = head; //注意理解：我們增加一個節點，放在第一個節點的前面，主要是為了便於比較。因為第一個節點沒有前驅，我們不能交換地址
head = p1; //讓head指向p1節點，排序完成后，我們再把p1節點釋放掉
for (endpt = NULL; endpt != head; endpt = p) //結合第6點理解
{
for (p = p1 = head; p1->next->next != endpt; p1 = p1->next)
{
if (p1->next->num > p1->next->next->num) //如果前面的節點鍵值比后面節點的鍵值大，則交換
{
p2 = p1->next->next; //結合第1點理解
p1->next->next = p2->next; //結合第2點理解
p2->next = p1->next; //結合第3點理解
p1->next = p2; //結合第4點理解
p = p1->next->next; //結合第6點理解
}
}
}
p1 = head; //把p1的信息去掉
head = head->next; //讓head指向排序后的第一個節點
free (p1); //釋放p1
p1 = NULL; //p1置為NULL，保證不產生“野指針”，即地址不確定的指針變量
return head;
}
reference: