寫在前面：本文僅供個人學習使用。《大話數據結構》通俗易懂，適合整體做筆記輸出，構建體系。并且文中很多圖片來源于該書。

文章目錄

• • 3.2 線性表的定義
  • 3.3 線性表的抽象數據類型
  • 3.4 線性表的順序存儲結構
  • • 3.4.1 順序存儲定義
    • 3.4.2 順序存儲方式
    • 3.4.3 數組長度與線性表長度的區別
    • 3.4.4 地址計算方法
  • 3.5 順序存儲結構的插入與刪除
  • • 3.5.1 獲得元素操作
    • 3.5.2 插入操作
    • 3.5.3 刪除操作
    • 3.5.4 線性表順序存儲結構的優缺點
  • 3.6 線性表的鏈式存儲結構
  • • 3.6.1 順序存儲結構不足的解決辦法
    • 3.6.2 線性表鏈式存儲結構定義
    • 3.6.3 頭指針和頭結點的異同
    • 3.6.4 線性表鏈式存儲結構代碼描述
  • 3.7 單鏈表的讀取
  • 3.8 單鏈表的插入與刪除
  • • 3.8.1 單鏈表的插入
    • 3.8.2 單鏈表的刪除
  • 3.9 單鏈表的整表創建
  • 3.10 單鏈表的整表刪除
  • 3.11 單鏈表結構與順序存儲結構優缺點
  • 3.12 靜態鏈表
  • • 3.12.1 靜態鏈表的插入操作
    • 3.12.2 靜態鏈表的刪除操作
    • 3.12.3 靜態鏈表優缺點
  • 3.13 循環鏈表
  • 3.14 雙向鏈表
  • 3.15 總結

線性表：零個或者多個數據元素的有限序列。

3.2 線性表的定義

舉個例子，一個班級的小朋友，一個跟著一個排隊，有一個打頭，一個結尾，當中的小朋友都知道他前面一個是誰，他后面一個是誰，這樣如同有一根線把他們串聯起來，就可以稱之為線性表。

線性表的定義

線性表(List):零個或多個數據元素的有限序列。

這里強調幾個關鍵的地方。

首先它是一個序列。也就是說，元素之間是有順序的，若元素存在多個，則第一個元素無前驅，最后一個元素無后繼，其他每個元素都有且只有一個前驅和后繼。如果一個小朋友去拉兩個小朋友后面的衣服，那就不可以排成一隊了；同樣，如果一個小朋友后面的衣服，被兩個甚至多個小朋友拉扯，這其實是在打架，而不是有序隊列。

然后，線性表強調是有限的，小朋友班級人數是有限的，元素個數當然是有限的。事實上，在計算機中處理的對象都是有限的，那種無限的數列，只存在于數學的概念中。

如果用數學的語言來定義線性表。可如下

若將線性表記為$(a_1,...,a_{i?1},a_i,...,a_n)$,則表中$a_{i?1}$領先于$a_i$，$a_i$領先于$a_{i+1}$，稱$a_{i?1}$是$a_i$的直接前驅元素，$a_{i+1}$是$a_i$的直接后繼元素。當i=1,2,…,n-1時，$a_i$有且僅有一個直接后繼，當i=2,3,…,n時，$a_i$有且僅有一個直接前驅。

所以線性表元素的個數n(n≥0)定義為線性表的長度，當n=0時，稱為空表。

在非空表中的每個數據元素都有一個確定的位置，如$a_1$是第一個數據元素，$a_n$是最后一個數據元素，$a_i$是第i個數據元素，稱i為數據元素$a_i$在線性表中的位序。

在較復雜的線性表中，一個數據元素可以由若干個數據項組成。

3.3 線性表的抽象數據類型

現在來看一下，線性表應該具有一些什么樣的操作呢？

還是回到剛才幼兒園小朋友的例子，老師為了讓小朋友有秩序地出入，所以就考慮給他們排一個隊，并且是長期使用的順序，這個考慮和安排的過程其實就是一個線性表的創建和初始化過程。

一開始沒經驗，把小朋友排好隊之后，發現有的高有的矮，隊伍很難看，于是讓小朋友解散重排–這是一個把線性表重置為空表的操作。

排好了隊，我們隨時可以叫出隊伍某一位置的小朋友名字及他的具體情況。這種可以根據位序得到數據元素也是一種很重要的線性表操作。

還有什么呢，有時我們想知道,某個小朋友，比如麥兜是否是班里的小朋友，老師會告訴我說，不是，麥兜在春田花花幼兒園里，不在我們幼兒園。這種查找某個元素是否存在的操作很常用。

而后有家長問老師，班里現在到底有多少個小朋友呀，這種獲得線性表長度的問題也很普遍。

顯然，對于一個幼兒園來說，加入一個新的小朋友到隊列中，或因某個小朋友生病，需要移除某個位置，都是很正常的情況。對于一個線性表來說，插入數據和刪除數據都是必須的操作。

所以，線性表的抽象數據類型如下：

ADT 線性表(List)Data線性表的數據對象集合為{a1,a2,...,an}，每個元素的數據類型均為DataType。其中，除第一個元素a1之外，每一個元素有且只有一個直接前驅元素，除了最后一個元素an外，每一個元素有且只有一個直接后繼元素。數據元素之間的關系是一對一的關系。 OperationInitList(*L) :初始化操作，建立一個空的線性表LListEmpty(L) :若線性表為空，返回true，否則返回falseClearList(*L) :將線性表清空GetElem(L,i,e) :將線性表L中的第i個位置元素值返回給eLocateElem(L,e) :在線性表L中查找與給定值e相等的元素，如果查找成功，返回該元素在表中的序號表示成功；否則返回0表示失敗。ListInsert(*L,i,e):在線性表L中的第i個位置插入新元素eListDelete(*L,i,*e):刪除線性表L中第i個位置元素，并用e返回其值。ListLength(L):返回線性表L的元素個數。 endADT

對于不同的應用，線性表的基本操作是不同的，上述操作是最基本的，對于實際問題中涉及的關于線性表的更復雜操作，完全可以用這些基本操作的組合來實現。

比如，要實現兩個線性表集合A和B的并集操作。即要使得集合A=A∪B。說白了，就是把存在集合B中但并不存在A中的數據元素插入到A中即可。

仔細分析一下這個操作，發現我們只要循環集合B中的每個元素，判斷當前元素是否在A中，若不存在，則插入到A中即可。思路是比較容易想到的。

我們假設La表示集合A，Lb表示集合B，則實現的代碼如下

void union(List *La,list Lb){int La_len,Lb_len,i;ElemType e;La_len=ListLength(La); //線性表的長度Lb_len=ListLength(Lb);for(int i=1;i<=Lb_len;i++){GetElem(Lb,i,e); //取出Lb中第i個數據放入到eif(!LocateElem(La,e,equal)) //La中不存在和e相同數據元素ListInsert(La,++La_len,e); //插入} }

這里，我們對于union操作，用到了前面線性表基本操作ListLength,GetElem,LocateElem,ListInsert等，可見，對于復雜的個性化的操作，其實就是基本操作組合起來實現的。

3.4 線性表的順序存儲結構

3.4.1 順序存儲定義

線性表的兩種物理結構其中之一—順序存儲結構

線性表的順序存儲結構，指的是用一段地址連續的存儲單元依次存儲線性表的數據元素。

可以看成去圖書館占位，連續占幾個位置。

3.4.2 順序存儲方式

線性表的順序存儲結構，說白了，就是在內存中找了塊地兒，通過占位的方式，把一定內存空間給占了，然后把相同類型的數據元素依次存放在這塊空地中。既然線性表中的每個數據元素的類型都相同，所以可以用C語言的一維數組來實現順序存儲結構，即把第一個數據元素存到數組下標為0的位置中，接著把線性表相鄰的元素存儲在數組中相鄰的位置。

為了建立一個線性表，要在內存中找一塊地，于是這塊地的第一個位置就非常關鍵，它是存儲空間的起始位置。

線性表中，我們估算這個線性表的最大存儲容量，建立一個數組，數組的長度就是這個最大存儲容量。 我們有了起始位置，也有了最大容量，于是我們就可以在里面增加數據了。隨著數據的插入，我們線性表的長度開始變大，不過線性表的當前長度不能超過存儲容量，即數組的長度。

來看線性表的順序存儲的結構代碼

#define MAXSIZE 30 // 存儲空間初始分配量 typedef int ElemType;// 數據元素類型typedef struct{ElemType data[MAXSIZE]; //數組存儲數據元素，最大值為MAXSIZEint length;//線性表當前的長度 }SqList;

這里，我們發現描述順序存儲結構需要三個屬性：

• 存儲空間的起始位置：數組data，它的存儲位置就是存儲空間的存儲位置
• 線性表的最大存儲容量：數組長度MaxSize
• 線性表的當前長度：length

3.4.3 數組長度與線性表長度的區別

注意哦，這里有兩個概念“數組的長度”和“線性表的長度”需要區分一下。

數組的長度時存放線性表的存儲空間的長度，存儲分配后這個量一般是不變的。但是可以采用編程手段實現動態分配數組，不過這會帶來性能上的損耗。

線性表的長度是線性表中數據元素的個數，隨著線性表插入和刪除操作的進行，這個量是變化的。

在任意時刻，線性表的長度應該小于等于數組的長度。

3.4.4 地址計算方法

c語言中從下標0開始，線性表的第i個元素存在數組下標為i-1的位置。

其實，內存中的地址，就和圖書館或電影院里的座位一樣，都是有編號的。存儲器中的每個存儲單元都有自己的編號，這個編號稱為地址。由于每個數據元素，不管它是整型、實型還是字符型，它都需要占用一定的連續存儲空間。假設占用的是c個連續單元，那么線性表中第i+1個數據元素的存儲位置和第i個數據元素的存儲位置滿足下列關系（LOC表示獲得存儲位置的函數）：

$LOC(a_{i+1})=LOC(a_i)+c$

所以對于第i個數據元素$a_i$的存儲位置可以由$a_1$推算得出：

$LOC(a_i)=LOC(a_1)+(i?1)\times c$

通過這個公式，可以隨時算出線性表中任意位置的地址，不管它是第一個還是最后一個，都是相同的時間。那么我們對每個線性表位置的存入或者取出數據，對于計算機而言都是相等的時間，也就是一個常數，所以它的存取時間性能是O(1)。我們通常把具有這一特點的存儲結構稱為隨機存取結構。

3.5 順序存儲結構的插入與刪除

3.5.1 獲得元素操作

實現GetElem操作，剛才提到過，順序存儲結構獲取元素操作時間復雜度為：O(1)

#define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0typedef int Status; // Status 是函數的類型，其值是函數結果狀態代碼，如OK等 // 初始條件：順序表L已存在，1≤L≤ListLength(L) //操作結果：用e返回L中第i個數據元素的值Status GetElem(SqList L,int i, ElemType *e){ //e這里用引用if(L.length==0 || i<1 || i>L.length)return ERROR;*e=L.data[i-1];return OK; }

注意這里返回值類型Status是一個類型，返回OK代表1，ERROR代表0.

3.5.2 插入操作

我們現在來考慮，如果我們要實現ListInsert(*L,i,e)，即在線性表L中的第i個位置插入新元素e，應該如何操作？

舉例：排隊時有人插隊在你前面，你和后面的人只能順序往后退。

插入算法的思路：

• 如果插入位置不合理，拋出異常；
• 如果線性表長度≥數組長度，則拋出異常或動態增加容量；
• 從最后一個元素開始向前遍歷到第i個位置，分別將它們都向后移動一個位置；
• 將要插入元素填入位置i處；
• 表長增加1.

實現的代碼如下:

Status ListInsert(SqList *L,int i,ElemType e){int k;//線性表滿了：if(L->length==MAXSIZE) //線性表已滿return ERROR;//下面都是在線性表沒滿的情況下：if(i<1 || i> L->length+1) //當i不在范圍內時return ERROR;if(i<=L->length){//若插入數據位置不在表尾for( k=L->length-1;k>=i-1;k--)L->data[k+1]=L->data[k];//一位位后移}L->data[i-1]=e; //將新元素插入L->length++;return OK; }

3.5.3 刪除操作

線性表的順序存儲結構刪除元素：刪除該位置，該位置后面的元素依次前移。

刪除算法的思路

• 如果刪除位置不合理，拋出異常；
• 取出刪除元素
• 從刪除元素位置開始遍歷到最后一個元素位置，分別將它們都向前移動一個位置；
• 表長減1 。

實現代碼如下：

//操作結果：刪除L的第i個元素，并用e返回其值，L的長度減1 Status ListDelete(SqList *L,int i,ElemType *e){int k;if(L->length==0) //如果線性表為空return ERROR;if(i<1 || i>L->length) //刪除位置不正確return ERROR;*e=L->data[i-1];if(i<L->length){ //i表示線性表中第i個元素，對應到data數組中下標是i-1for(k=i;k<L->length;k++)L->data[k-1]=L->data[k]; //將刪除位置后繼元素前移}L->length--;return OK; }

下面我們來分析一下，插入和刪除的時間復雜度。

先來看最好的情況，如果元素要插入到最后一個位置，或者刪除最后一個元素，此時時間復雜度為O(1),因為不需要移動元素，就如同來了一個新人要正常排隊，當然是排在最后，如果此時他又不想排了，那么他一個人離開就好，不影響任何人。

最壞的情況呢？ 如果元素要插入到第一個位置或者刪除第一個元素，此時時間復雜度是多少呢？那就意味著要移動所有的元素向后或者向前，所以這個時間復雜度是O(n).

至于平均的情況，由于元素插入到第i個位置，或刪除第i個元素，需要移動n-i個元素。根據概率原理，每個位置插入或刪除元素的可能性是相同的，也就說位置靠前，移動元素多，位置靠后，移動元素少。最終平均移動次數和最中間的那個元素的移動次數相等，為$\frac{n?1}{2}$，所以平均時間復雜度為O(n)。

這說明什么？ 線性表的順序存儲結構，在存、讀數據時，不管是哪個位置，時間復雜度都是O(1);而插入或刪除時，時間復雜度都是O(n)。就說明，它比較適合元素個數不太變化，而更多是存取數據的應用。當然，它的優缺點還不只這些……

3.5.4 線性表順序存儲結構的優缺點

優點缺點

無須為表示表中元素之間的邏輯關系而增加額外的存儲空間	插入和刪除操作需要移動大量元素
可以快速地存取表中任意位置的元素	當線性表長度變化較大時，難以確定存儲空間的容量
	造成存儲空間的“碎片”

3.6 線性表的鏈式存儲結構

3.6.1 順序存儲結構不足的解決辦法

前面我們提到的線性表的順序存儲結構，它是有缺點的，最大的缺點就是插入和刪除時需要移動大量元素，這顯然需要消耗時間。能不能想解決辦法？

要解決這個問題，我們就得考慮一下導致這個問題的原因。

為什么當插入和刪除時，就要移動大量元素，仔細分析后，發現原因就在于相鄰兩元素的存儲位置也具有鄰居關系。它們的編號是1,2,…,n，它們在內存中的位置也是挨著的，中間沒有空隙，當然就無法快速介入，而刪除后，當中就會留出空隙，自然需要彌補。問題就出在這里。

A同學思路：讓當中每個元素之間都留有一個空位置，這樣要插入時，就不至于移動。可一個空位置如何解決插入多個數據的問題呢？所以這個想法顯然不行。

B同學思路：那就讓當中每個元素之間都留有足夠多的位置，根據實際情況制定空隙大小，比如10個，這樣插入時，就不需要移動了。萬一10個空位用完了，再考慮移動使得每個位置之間都有10個空位置。如果刪除，就直接刪除，把位置留空即可。這樣似乎暫時解決了插入和刪除的移動數據問題。可這對于超過10個同位置數據的插入，效率上還是存在問題。對于數據的遍歷，也會因為空位置太多而造成判斷時間上的浪費。而且顯然這里空間復雜度還增加了，因為每個元素之間都有若干個空位置。

C同學思路：我們反正也是要讓相鄰元素間留有足夠余地，那干脆所有的元素都不考慮相鄰位置了，哪有空位就到哪里，而只是讓每個元素知道它下一個元素位置在哪里，這樣，我們就可以在第一個元素時，就知道第二個元素的位置（內存地址），而找到它；在第二個元素時，再找到第三個元素的位置。這樣所有的元素我們就都可以通過遍歷而找到。

好！太棒了，這個想法非常好！C同學，你可惜生晚了幾十年，不然，你的想法對于數據結構來講就是劃時代的意義。我們要的就是這個思路。

注：這里完全照搬《大話數據結構》中的措辭。

3.6.2 線性表鏈式存儲結構定義

線性表的鏈式存儲結構的特點是用一組任意的存儲單元存儲線性表的數據元素，這組存儲單元可以是連續的，也可以是不連續的。這就意味著，這些數據元素可以存在內存未被占用的任意位置。如圖3-6-1所示。

以前在順序結構中，每個數據元素只需要存數據元素信息就可以了。現在鏈式結構中，除了要存數據元素信息外，還要存儲它的后繼元素的存儲地址。

因此，為了表示每個數據元素$a_i$與其直接后繼元素$a_{i+1}$之間的邏輯關系，對數據元素$a_i$來說，除了存儲其本身的信息之外，還需存儲一個指示其直接后繼的信息（即直接后繼的存儲位置）。我們把存儲數據元素信息的域稱為數據域，把存儲直接后繼位置的域稱為指針域。指針域中存儲的信息稱為指針或鏈。這兩部分信息組成數據元素$a_i$的存儲映像，稱為結點（Node）。

n個結點($a_i$的存儲映像)鏈接成一個鏈表，即為線性表($a_1,a_2,...,a_n$)的鏈式存儲結構，因為此鏈表的每個結點中只包含一個指針域，所以叫作單鏈表。

單鏈表正是通過每個結點的指針域將線性表的數據元素按其邏輯順序鏈接在一起，如下圖所示。

對于線性表來說，總得有個頭有個尾，鏈表也不例外。我們把鏈表中第一個結點的存儲位置叫作頭指針，那么整個鏈表的存取就必須是從頭指針開始進行了。之后的每一個結點，其實就是上一個后繼指針指向的位置。

最后一個結點，當然就意味著直接后繼不存在了，所以我們規定，線性鏈表的最后一個結點指針為“空”（通常用NULL或“^”符號表示），如下圖所示。

有時，我們為了更加方便對鏈表進行操作，會在單鏈表的第一個結點前附設一個結點，稱為頭結點。頭結點的數據域可以不存儲任何信息，也可以存儲如線性表的長度等附加信息，頭結點的指針域存儲指向第一個結點的指針。如下圖所示

3.6.3 頭指針和頭結點的異同

頭指針頭結點

頭指針是指鏈表指向第一個結點的指針，若鏈表有頭結點，則是指向頭結點的指針	頭結點是為了操作的統一和方便而設立的，放在第一元素的結點之前，其數據域一般無意義（也可存放鏈表的長度）
頭指針具有標識作用，所以常用頭指針冠以鏈表的名字	有了頭結點，對在第一元素結點前插入結點和刪除第一結點，其操作與其他結點的操作就統一了
無論鏈表是否為空，頭指針均不為空。頭指針是鏈表的必要元素	頭結點不一定是鏈表必須元素

3.6.4 線性表鏈式存儲結構代碼描述

若線性表為空表，則頭結點的指針域為“空”，如圖所示

這里我們大概用圖示表達了內存中單鏈表的存儲狀態。我們關心的是它在內存中的實際位置嗎？不是的，這只是它所表示的線性表中的數據元素及數據元素之間的邏輯關系。我們我們改用更方便的存儲示意圖來表示單鏈表。如下圖所示

若帶頭結點的單鏈表，如下圖

空鏈表如圖所示

單鏈表中，我們在C語言中可用結構指針來描述

//線性表的單鏈表存儲結構 typedef struct Node{ElemType data;struct Node *next; }Node;typedef struct Node *LinkList;//定義結構指針Linklist

從這個結構定義中，我們也就知道，結點由存放數據元素的數據域和存放后繼結點地址的指針域組成。

假設p是指向線性表第i個元素的指針，則該結點ai的數據域我們可以用p->data來表示,p->data的值是一個數據元素，結點ai的指針域可以用p->next來表示，p->next的值是一個指針。p->next指向誰呢？當然是指向第i+1個元素，即指向$a_{i+1}$的指針。也就是說，如果$p?>data=a_i,那么p?>next?>data=a_{i+1}$.

3.7 單鏈表的讀取

在線性表的順序存儲結構中，我們要計算任意一個元素的存儲位置是很容易的。但在單鏈表中，由于第i個元素到底在哪沒法一開始就知道，必須得從頭開始找。因此，對于單鏈表實現獲取第i個元素的數據的操作GetElem上，相對要麻煩一些。

獲取鏈表第i個數據的算法思路：

聲明一個結點p指向鏈表第一個結點，初始化j從1開始；

當j<i時，就遍歷鏈表，讓p的指針往后移動，不斷指向下一結點，j累加1；

若到鏈表末尾p為空，則說明第i個元素不存在；

否則查找成功，返回結點p的數據。

實現代碼：

Status GetElem(LinkList L,int i,ElemType *e){int j;LinkList p;//聲明一個結點pp=L->next; //讓p指向鏈表L的第一個結點j=1; //j為計數器while(p && j <i){ //p不為空 或者計數器j沒有等于i時，循環繼續p=p->next;++j; }if( !p || j>i){ //p為空或者 j＞i 則沒有該元素return ERROR; }*e=p->data; //取出第i個元素的數據 return OK;}

說白了，就是從頭開始找，直到第i個元素為止。由于這個算法的時間復雜度取決于i的位置，當i=1時，不需要遍歷；當i=n時需要遍歷n-1次，因此最壞情況的為O(n).

3.8 單鏈表的插入與刪除

3.8.1 單鏈表的插入

將結點s(里面的數據是e)插入到結點p和結點p->next之間

s->next=p->next; p->next=s;

考慮一下，這兩句的順序可不可以交換？

如果先p->next=s;再s->next=p->next;會怎么樣？

這樣是錯誤的。p->next=s;s的地址覆蓋掉p->next，那么s->next=p->next就是 s->next=s，這樣真正擁有$a_{i+1}$數據元素的結點就沒了上級。也就是掉了鏈子。

對于單鏈表的表頭和表尾的特殊情況，操作是相同的。

單鏈表第i個數據插入結點的算法思路：

聲明一個結點p指向鏈表第一個結點，初始化j從1開始；

當j<i時，就遍歷鏈表，讓p的指針向后移動，不斷指向下一個結點，j++；

若到鏈表末尾p為空，則說明第i個元素不存在；

否則查找成功，在系統中生成一個空結點s；

將數據元素e賦值給s->data；

單鏈表的插入標準語句是 s->next=p->next;p->next=s;

返回成功

實現代碼

Status ListInsert(LinkList *L,int i,ElemType e){int j;LinkList p,s;p=*L;j=1;while(p&& j<i){ // 尋找第i個結點,退出條件是p為空或者 j==ip=p->next;++j;}if(!p || j>i){return ERROR; //不存在第i個元素}s=(LinkList)malloc(sizeof(Node)); //生成新結點s->data=e;//賦值s->next=p->next; //插入結點sp->next=s;return OK;}

在這段代碼中，我們用到了C語言的malloc函數，它的作用是生成一個新的結點，其類型與Node一樣，其實質就是在內存中找了一小塊空地，準備用來存放e數據s結點。

3.8.2 單鏈表的刪除

設存儲元素ai的結點為q，現在要實現將結點q刪除單鏈表的操作，其實就是將它的前驅結點的指針繞過q，指向它的后繼結點即可。如圖3-8-5所示。

我們要做的其實就是一步：p->next=p->next->next; 用q來代替p->next 就是

q=p->next; p->next=q->next;

單鏈表第i個數據刪除結點的算法思路：

聲明一個結點p指向鏈表的第一個結點，初始化j從1開始；

當j<i時，就遍歷鏈表，讓p的指針向后移動，不斷指向下一個結點，j++；

若到鏈表末尾p為空，則說明第i個元素不存在；

否則查找成功，將欲刪除的結點p->next 賦值為q；

單鏈表的刪除標準語句：p->next=q->next;

將q結點中的數據賦值為e，作為返回；

釋放q結點；

返回成功。

代碼實現：

Status ListDelete(LinkList *L,int i,ElemType *e){int j;LinkList p,q;//結點p和qp=*L;//指向第一個結點j=1;while(p->next && j<i){ //遍歷尋找第i個元素（即p->next）p=p->next;++j;}if(!(p->next)||j>i){ //第i個元素不存在return ERROR; }q=p->next;p->next=q->next;*e=q->data; //將q結點中的數據給efree(q); //系統回收該結點，釋放內存return OK; }

這段代碼中，我們用到了C語言標準函數free，它的作用是讓系統回收一個Node結點，釋放內存。

分析一下單鏈表的插入和刪除操作，其實它們由兩部分組成：第一部分就是遍歷查找第i個元素；第二部分就是插入和刪除元素。

從整個算法來說，我們容易推斷出：它們的時間復雜度都是O(n)。如果不知道第i個元素的指針位置，單鏈表數據結構在插入和刪除操作上，與線性表的順序存儲結構相比沒有太大優勢。但如果，我們希望從第i個位置開始，插入10個元素，對于順序存儲結構意味著，每一個插入都需要移動n-i個元素，每次都是O(n)。而單鏈表，我們只需要在第一次時，找到第i個位置的指針，此時為O(n)，接下來只是簡單地通過賦值移動指針而已，時間復雜度都是O(1)。顯然，對于插入或刪除數據頻繁的情形，單鏈表的效率優勢就很明顯了。

3.9 單鏈表的整表創建

回顧一下，順序存儲結構的創建，其實就是數組的初始化過程，即聲明一個類型和大小確定的數組并賦值的過程。而單鏈表和順序存儲結構不一樣，它不像順序存儲結構那樣集中，它可以很分散，是一種動態結構。對于每個鏈表來說，它所占用的空間的大小和位置是不需要提前分配的，可以根據系統的情況和實際的需求及時生成。

所以創建單鏈表的過程就是一個動態生成鏈表的過程，即從“空表”的初始狀態起，依次建立各元素結點，并逐個插入鏈表。

單鏈表整表創建的算法思路：

聲明一個結點p和計數器變量i；

初始化一空鏈表L；

讓L的頭結點的指針指向NULL，即建立一個帶頭結點的單鏈表；

循環：生成一新結點賦值給p；隨機生成一數字賦值給p的數據域p->data;將p插入到頭結點與前一新結點之間。

實現代碼（頭插法）：

void CreateListHead( LinkList *L,int n){LinkList p;int i;srand(time(0)); //初始化隨機數種子*L=(LinkList)malloc(sizeof(Node)); (*L)->next=NULL;//建立一個帶頭結點的單鏈表for(i=0;i<n;i++){p=(LinkList)malloc(sizeof(Node)); //生成新結點p->data=rand()%100+1;//隨機生成100以內的數字p->next=(*L)->next;(*L)->next=p;//插入到表頭}}

這段代碼里，我們其實用的是插隊的辦法，就是始終讓新結點在第一的位置，因此稱為頭插法。如圖所示

可事實上，我們還是可以不這樣干，為什么不把新結點都放到最后呢？這才是排隊時的正常思維啊，所謂的先來后到。我們把每次新結點都插入到終端結點的后面，這種算法稱為尾插法。

實現代碼（尾插法）：

void CreateListTail(LinkList *L,int n){LinkList p,r;int i;srand(time(0));*L=(LinkList)malloc(sizeof(Node)); //L是整個單鏈表r=*L;//r為指向尾部的結點for(i=0;i<n;i++){p=(Node *)malloc(sizeof(Node)); //生成新結點p->data=rand()%100+1;r->next=p;r=p;//將當前的新結點定義為尾部終端結點}r->next=NULL; //表示當前鏈表結束}

注意L和r的關系，L是指整個單鏈表，而r是指向尾結點的變量，變量r會隨著循環不斷變化，而L則是隨著循環增長為一個多結點的鏈表。

3.10 單鏈表的整表刪除

當我們不打算使用這個單鏈表時，我們需要把它銷毀，其實也就是在內存中將它釋放掉，以便于留出空間給其他程序或軟件使用。

單鏈表整表刪除的算法思路如下：

聲明一結點p和q；

將第一個結點賦值給p；

循環：將下一結點賦值給q；釋放p；將q賦值給p。

實現代碼

Status ClearList(LinkList *L){//默認鏈表帶有頭結點LinkList p,q;//申明兩個結構體變量，即結點p=(*L)->next; //p指向第一個結點while(p){// 沒到表尾q=p->next;free(p);p=q;}(*L)->next=NULL; //頭結點指針域為空return OK;}

這段代碼里，常見的錯誤就是有同學會覺得q變量沒有必要存在。在循環體中直接寫free§;p=p->next;不就行了嗎？可這樣會帶來什么問題？

要知道p是一個結點，它除了有數據域，還有指針域。在做free (p )時，其實是對它整個結點進行刪除和內存釋放的工作。直接刪除就不知道和它關聯的后繼是誰了，而變量q的作用，使得下一個結點是誰得到記錄，以便等當前結點釋放后，把下一個結點拿過來補充。

3.11 單鏈表結構與順序存儲結構優缺點

簡單地對單鏈表結構和順序存儲結構做對比：

存儲分配方式時間性能空間性能

順序存儲結構用一段連續的存儲單元依次存儲線性表的數據元素	查找性能：順序存儲結構O(1);單鏈表O(n)	順序存儲結構需要預分配存儲空間，分大了浪費；分小了易發生上溢
單鏈表采用鏈式存儲結構，用一組任意的存儲單元存放線性表的元素	插入和刪除性能：順序存儲結構需要平均移動表長一半的元素，時間為O(n);單鏈表在找出某位置的指針后，插入和刪除時間僅為O(1)	單鏈表不需要分配存儲空間，只要有就可以分配，元素個數不受限制

通過上面的對比，我們可以得到一些經驗性的結論：

• 若線性表需要頻繁查找，很少進行插入和刪除操作時，宜采用順序存儲結構。若需要頻繁插入和刪除時，宜采用單鏈表結構。比如說，游戲開發中，對于用戶注冊的個人信息，除了注冊時插入數據外，絕大多數情況都是讀取，所以應該考慮用順序存儲結構。而游戲中玩家的武器或者裝備列表，隨著玩家的游戲過程，可能會隨時增加或刪除，此時再用順序存儲結構存儲就不太適合了，單鏈表結構就可以大展身手。當然，這只是簡單類比，現實中軟件開發還需要考慮更多的問題。
• 當線性表中的元素個數變化較大或者根本不知道有多大時，最好用單鏈表結構，這樣可以不需要考慮存儲空間的大小問題。而如果事先知道線性表的大致長度，比如一年12個月，這種采用順序存儲結構效率會高很多。

總之，線性表的順序存儲結構和單鏈表結構各有優缺點，不能簡單說哪個好，哪個不好。

3.12 靜態鏈表

C語言具有指針功能，使得它可以容易地操作內存中的地址和數據，而對于一些語言，由于沒有指針，鏈表結構是如何實現的呢？

有人就想出用數組代替指針，來描述單鏈表。

首先我們讓數組的元素都是由兩個數據域組成，data和cur。也就是說，數組的每個下標都對應一個data和一個cur。數據域data，用來存放數據元素，也就是通常我們要處理的數據；而游標cur相當于單鏈表中的next指針，存放該元素的后繼在數組中的下標。

我們把這種用數組描述的鏈表叫做靜態鏈表。

為了便于插入數據，通常會把數組建的大一些，以便有一些空閑空間可以使得插入時不會溢出。

#define MAZSIZE 1000 typedef struct{ElemType data;int cur; //游標，為0時表示無指向 }Component,StaticLinkList[MAXSIZE];

另外我們把數組的第一個和最后一個元素作為特殊元素處理，不存放數據。通常把未被使用的數組元素組成的數組稱為備用鏈表。而數組的第一個元素，即下標為0的元素的cur就存放備用鏈表的第一個結點的下標；而數組的最后一個元素的cur則存放第一個有數值的元素的下標，相當于單鏈表中的頭結點，當整個鏈表為空時，則為0.如下圖所示

此時圖示相當于初始化的數組狀態，見下面代碼

//將一維數組space中各分量連成一個備用鏈表 //space[0].cur為頭指針，0表示空指針 Status InitList(StaticLinkList space){int i;for(i=0;i<MAXSIZE-1;i++)space[i].cur=i+1;space[MAXSIZE-1].cur=0;//目前靜態鏈表為空，最后一個元素的cur為0return OK; }

假設我們已經將數據存入靜態鏈表，比如分別存放著甲乙丙丁戊己庚等數據

此時，“甲”這里就存有下一元素“乙”的游標2，“乙”則存放著下一元素“丁”的下標3.而“庚”是最后一個有值元素，所以它的cur設置為0.而最后一個元素的cur則因為“甲”是第一有值元素，所以存有“甲”的下標1.而第一個元素則因為空閑空間的第一個元素下標為7，所以它的cur存有7.

3.12.1 靜態鏈表的插入操作

靜態鏈表要解決的是：如何用靜態模擬動態鏈表結構的存儲空間的分配，需要時申請，無用時釋放。

我們前面說過，在動態鏈表中，結點的申請和釋放分別通過malloc和free兩個函數來實現。在靜態鏈表中，操作的是數組，不存在像動態鏈表的結點申請和釋放問題，所以我們需要自己實現這兩個函數，才可以做插入和刪除的操作。

為了辨明數組中哪些分量未被使用，解決的辦法是將所有未被使用過和已被刪除的分量用游標鏈接成一個備用的鏈表，每當進行插入時，便可以從備用鏈表上取得第一個結點作為待插入的新結點。

//若備用空間鏈表非空，則返回分配的結點下標，否則返回0 int Malloc_SLL(StaticLinkList space){int i=space[0].cur; //當前備用鏈表第一個結點iif(space[0].cur){ //如果結點i被分配space[0].cur=space[i].cur;// 把i的后繼作為備用鏈表的第一個結點} return i; //返回分配的結點下標i}

這段代碼，一方面返回一個下標值，這個值就是數組頭元素的cur，它里面存的第一個空閑的下標，從下圖可以看到，這個值是7.

那么既然下標為7的分量準備要使用了，就得有接替者，所以就把分量7的cur值賦值給頭元素，也就是把8給space[0].cur，之后就可以繼續分配新的空間分量，實現類似malloc函數的作用。（這里需要理解一下，筆者第一遍只看代碼沒看解釋時，感到有點迷惑。）

現在我們如果需要在“乙”和“丁”之間，插入一個值為“丙”的元素，按照以前順序存儲結構的做法，應該把后面這些元素往后移，但目前我們不需要，因為我們有了新的手段。

新元素“丙”，想插隊是吧？可以，你先悄悄地在隊伍最后一排第7個游標位置呆著，我一會兒就幫你搞定。我接著找到了“乙”，告訴他，你的cur不是游標3的“丁”了，這點小錢，意思意思，你把你的下一位的游標改為7就可以了。“乙”嘆一口氣，收了錢把cur值給改了。此時再回到“丙”那里，說你把你的cur改為3.就這樣，在絕大多數人都不知道的情況下，整個排隊的次序發生了變化。如圖所示

代碼

• 當我們執行插入語句時，我們的目的是要在“乙”“丁”插入“丙”。調用代碼時，輸入i值為3.
• 第3行讓k=MAXSIZE-1=999;
• 第5行，j=Malloc_SLL(L)=7;此時下標為0的cur也因為7要被占用而更改為備用鏈表的值為8.
• 第8~9行，for循環l由1到2（因為i=3），執行兩次.代碼k=L[k].cur=L[999].cur=1，再得到k=L[1].cur=2;
• 第10行，L[j].cur=L[k].cur；因為j=7，而k=2，得到L[7].cur=L[2].cur=3.這就是剛才讓“丙”把它的cur改為3，即丙的后面是丁。
• 第11行，L[k].cur=j;意思就是L[2].cur=7。也就是讓“乙”得點好處，把它的cur改為指向“丙”的下標。

就這樣，我們實現了在數組中，實現不移動元素，卻插入了數據的操作。

//在L中第i個元素之前插入新的數據元素e Status ListInsert(StaticLinkList L,int i,ElemType e){int j,k,l;k=MAXSIZE-1; //注意k首先是最后一個元素的下標if(i<1 || i>ListLength(L)-1) return ERROR; j=Malloc_SLL(L);//獲得空閑分量的下標 if(j){L[j].data=e;for(l=1;l<=i-1;l++) //找到第i個元素之前的位置k=L[k].cur;L[j].cur=L[k].cur;//把第i個元素之前的cur賦值給新元素的curL[k].cur=j;//把新元素的下標賦值給第i個元素之前元素的curreturn OK;}return ERROR; }

3.12.2 靜態鏈表的刪除操作

故事沒完，接著，排在第一位的甲突然接到一個電話，看著很急，毫不猶豫就匆匆離開。這意味著第一位空出來了，那么自然剛才的乙便排到了第一位。和前面一樣，刪除元素時，原來是需要釋放結點的函數free，現在我們也得自己實現它

//刪除在L中第i個數據元素e Status ListDelete(StaticLinkList L,int i){int j,k;if(i<1 || i>ListLength(L)-1) return ERROR;k=MAXSIZE-1;for(j=1;j<=i-1;j++)k=L[k].cur;//k得到i前面的結點j=L[k].cur;//得到第i個結點L[k].cur=L[j].cur; //把乙的位置賦給k這個結點的cur,就是刪除了甲Free_SLL(L,j);return OK;}

Free_SLL(L,j)是什么意思呢？ 來看代碼

//將下標為k的空閑結點回收到備用鏈表void Free_SLL(StaticLinkList space ,int k){space[k].cur=space[0].cur; //k這個結點的后繼是原來空閑鏈表的第一個結點space[0].cur=k; //備用鏈表的第一個結點變成 k這個結點 }

意思就是“甲”現在要走，這個位置就空出來了，也就是，未來如果有新人來，最優先考慮這里，所以原來的第一個空位分量，即下標是8的分量，它降級了，把8給“甲”所在下標為1的分量的cur，也就是space[1].cur=space[0].cur=8,而space[0].cur=k=1 其實就是讓這個刪除的位置成為第一個優先空位，把它存入第一個元素的cur中，如圖所示

備注：如果這里不好理解，可能是對第一個元素和最后一個元素的作用有所淡忘，這里再次貼出便于復習。

數組的第一個元素，即下標為0的元素的cur就存放備用鏈表的第一個結點的下標；而數組的最后一個元素的cur則存放第一個有數值的元素的下標，相當于單鏈表中的頭結點，當整個鏈表為空時，則為0.如下圖所示

當然，靜態鏈表也有相應的其他操作的相關實現，比如前面代碼中出現的ListLength就是一個，來看代碼

int ListLength(StaticLinkList L){int j=0;int i=L[MAXSIZE-1].cur;//第1個元素的下標while(i){//沒到空結點i=L[i].cur;//后移j++;//計數器++}return j;//返回計數器}

3.12.3 靜態鏈表優缺點

總結一下靜態鏈表的優缺點

優點缺點

在插入和刪除操作時，只需要修改游標，不需要移動元素，從而改進了在順序存儲結構中的插入和刪除操作需要大量移動元素的缺點	1.沒有解決連續存儲分配帶來的表長難以確定的問題；2.失去了順序存儲結構隨機存取（存取時間都是O(1)）的特性

總的來說，靜態鏈表其實是為了給沒有指針的高級語言設計的一種實現單鏈表功能的辦法。盡管大家不一定會用得上，但是這樣的思考方法是很巧妙的，應該理解其思想，以備不時之需。

3.13 循環鏈表

對于單鏈表，由于每個結點只存儲了向后的指針，到了尾標志就停止了向后鏈的操作，這樣，當中某一結點就無法找到它的前驅結點了。也就是說，從當中一個結點遍歷整個鏈表，對單鏈表來說是不可能的。

將單鏈表中終端結點的指針端由空指針改為指向頭結點，就使整個單鏈表形成一個環，這種頭尾相接的單鏈表稱為單循環鏈表，簡稱循環鏈表（circular linked list）.

這樣，循環鏈表解決了一個很麻煩的問題，就如如何從當中一個結點出發，訪問到鏈表的全部結點。

為了使空鏈表和非空鏈表處理一致，我們通常設一個頭結點，當然，這并不是說，循環鏈表一定要頭結點，這需要注意。 循環鏈表帶有頭結點的空鏈表如下圖所示

而非空的循環鏈表如下圖

其實循環鏈表和單鏈表的主要差異就在于循環的判斷條件上，原來是判斷p->next是否為空，現在則是p->next不等于頭結點，則循環未結束。

在單鏈表中，我們有了頭結點時，可以用O(1)的時間訪問到第一個結點，但對于要訪問到最后一個結點，卻需要O(n)的時間，因為我們需要將單鏈表全部掃描一遍。

有沒有可能用O(1)的時間由鏈表指針訪問到最后一個結點呢？當然可以。

不過我們需要改造一下這個循環鏈表，不用頭指針，而是用指向終端結點的尾指針來表示循環鏈表，如下圖所示，此時查找開始結點和終端結點都很方便。

從上圖可以看出，終端結點用尾指針rear指示，則查找終端結點是O(1),而開始結點，其實就是rear->next->next，其時間復雜度也是O(1).

舉個程序的例子，要將兩個循環鏈表合并成一個表時，有了尾指針就很簡單。比如下面的兩個循環鏈表，它們的尾指針分別是rearA和rearB。

要想把它們合并，只需要如下的操作即可

p=rearA->next;//保存A表的頭結點 對應序號① rearA->next=rearB->next->next; // 連接序號② rearB->next=p; //將原A表的頭結點賦值給rearB->next ,即序號③ free(p); //釋放p

3.14 雙向鏈表

我們在單鏈表中，有了next指針，這就使得我們要查找下一結點的時間復雜度為O(1)。可是如果我們要查找的是上一結點的話，那最壞的時間復雜度便是O(n)，因為我們每次都要從頭開始遍歷查找。

為了克服單向鏈表的這一缺點，哪些老科學家們，設計了雙向鏈表。雙向鏈表(double linked list)是在單鏈表的每個結點中，再設置一個指向其前驅結點的指針域。所以在雙向鏈表中的結點都有兩個指針域，一個指向直接后繼，一個指向直接前驅。

//線性表的雙向鏈表存儲結構 typedef struct DulNode{ElemType data;struct DulNode *prior; //直接前驅指針struct DulNode *next; //直接后繼指針 }DulNode,*DuLinkList;

既然單鏈表也可以有循環鏈表，那么雙向鏈表當然也可以是循環鏈表。
雙向鏈表的循環帶頭結點的空鏈表如下圖

非空的循環的帶頭結點的雙向鏈表如下圖所示

由于這是雙向鏈表，那么對于鏈表中的某一個結點p，它的后繼的前驅是誰？當然還是它自己。它的前驅的后繼自然也是它自己。即

p->next->prior=p=p->prior->next;

這就如同上海的下一站是蘇州，那么上海的下一站的前一站是哪里？ 廢話哦。

雙向鏈表是單鏈表擴展出來的結構，所以它的很多操作是和單鏈表相同的，比如求長度的ListLength，查找元素的GetElem，獲得元素位置的LocateElem等，這些操作都只要涉及一個方向的指針即可，另一指針多了也不能提供什么幫助。

就像人生一樣，想享樂就得先努力，欲收獲就得付代價。雙向鏈表既然是比單鏈表多了比如可以反向遍歷等功能的數據結構，那么也就需要付出一些小的代價：在插入和刪除時，需要更改兩個指針變量。

插入操作時，其實并不復雜，不過順序很重要，千萬不能寫反。

我們現在假設存儲元素e的結點為s，要實現將結點s插入到結點p和結點p->next之間需要下面幾步，如下圖

s->prior=p;//把p賦值給s的前驅 s->next=p->next;//把p->next賦值給s的后繼 p->next->prior=s;把s賦值給p->next的前驅 p->next=s;//把s賦值給p的后繼

關鍵在于它們的順序，由于第2步和第3步都用到了p->next，如果第4步先執行，則會使得p->next提前變成了是，使得插入的工作完成不了。所以我們不妨把上面這張圖在理解的基礎上進行記憶，順序是先搞定s的前驅和后繼，再搞定后結點的前驅，最后解決前結點的后繼。

如果插入操作理解了，那么刪除操作，就比較簡單了。

若要刪除結點p，只需要下面兩步驟，如下圖

p->prior->next=p->next; p->next->prior=P->prior; free(p);

好了，簡單總結一下，雙向鏈表相對于單鏈表來說，要更復雜一些，畢竟它多了prior指針，對于插入和刪除操作，需要格外小心。另外它由于每個結點都需要記錄兩份指針，所以在空間上是要占用略多一些的。不過，由于它良好的對稱性，使得對某個結點的前后節點的操作，變得很方便，可以有效提高算法的時間性能。說白了，就是用空間換時間。

3.15 總結

總結

以上是生活随笔為你收集整理的《大话数据结构》读书笔记-线性表的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。