線性表的鏈式儲存結構

  我們知道線性表的順序儲存結構在插入和刪除操作時需要移動大量的資料，他們的時間複雜度為O(n)$O(n)$。當我們需要經常插入和刪除資料時，順序儲存結構就不適用了，這時我們就需要用到線性表的鏈式儲存結構。
  線性表的鏈式儲存結構的特點是用一組任意的儲存單元儲存線性表的資料元素，這組儲存單元可以是連續的，也可以是不連續的。這就意味著，這些資料元素可以存在記憶體未被佔用的任意位置。我們先來看下鏈式儲存結構。
        

圖1單鏈表的示意圖$$圖1單鏈表的示意圖$$
  上圖是鏈式儲存結構中單鏈表的示意圖。從圖中，我們可以看出一個鏈式儲存結構由若干個結點（Node），串聯而成。每個結點有兩個部分，資料域和指標域。資料域中儲存資料元素，指標域中儲存後繼指標地址。為了能夠找到連結串列位置，就需要一個指向連結串列第一個元素的指標，我們把它稱為頭指標。此外，我們把連結串列中第一個結點叫做頭結點。頭結點的資料域一般不儲存任何資訊，也可以用於儲存線性表的長度等附加資訊。

線性錶鏈式儲存結構程式碼描述

  下面我們以單鏈表為例，可以用C++的類來描述。

class Node
{
public:
    Node();
    ~Node();
    friend void traverse_list(Node *pHead);//輸出整個連結串列
    friend Node * create_list();//建立非迴圈單鏈表
    friend bool is_empty_list(Node *pHead);//判斷是否為空
    friend int length_list(Node *pHead);//連結串列長度
    friend bool insert_list(Node *pHead, int
 
 pos, int val);//在pos位置插入值val
    friend bool delet_list(Node *pHead, int pos , int*pval);//將pos位置的值刪除
    friend void sort_list(Node *pHead);//排序
private:
    int data;//資料域
    Node *pNext;//指標域
};

  我們再看下每個操作的具體實現程式碼：

Node * create_list()//建立非迴圈單鏈表
{
    int len;
    int val;//存放臨時的值
    cout << "請輸入要生成的連結串列節點的個數:len="
 
;
    cin >> len;
    cout << endl;
    Node* pHead = new Node;//頭節點
    pHead->pNext = NULL;
    Node* pTail = pHead;
    for (int i = 0; i < len; i++)
    {
        cout << "請輸入第" << i + 1 << "個節點的值：";
        cin >> val;
        cout << endl;
        Node* pNew = new Node;
        pNew->data = val;
        pTail->pNext = pNew;
        pNew->pNext = NULL;
        pTail = pNew;
    }
    return pHead;

}
void traverse_list(Node *pHead)//輸出整個連結串列
{
    Node *p = pHead->pNext;
    while (p != NULL)
    {
        cout << p->data << endl;
        p = p->pNext;
    }
}
bool is_empty_list(Node *pHead)//判斷是否為空
{
    return pHead->pNext == NULL ? true : false;
}
int length_list(Node *pHead)//連結串列長度
{
    Node* p = pHead;
    int len = 0;
    while (p->pNext != NULL)
    {
        len++;
        p = p->pNext;
    }
    return len;
}
void sort_list(Node *pHead)//排序
{
    int i, j, t;
    int len = length_list(pHead);
    Node *p, *q;
    for (i = 0, p = pHead->pNext; i < len - 1; i++, p = p->pNext)
    {
        for (j = i+1, q = p->pNext; j < len; j++, q = q->pNext)
        {
            if (p->data > q->data)
            {
                t = p->data;
                p->data = q->data;
                q->data = t;
            }
        }
    }

}
bool insert_list(Node *pHead, int pos, int val)//在pos位置插入值val
{
    int i = 0;
    Node* p=pHead;
    while (p != NULL&&i < pos - 1)
    {
        p = p->pNext;
        i++;
    }
    if (i>pos - 1 || p == NULL)
        return false;

    Node*pNew = new Node;
    pNew->data = val;
    pNew->pNext = p->pNext;
    p->pNext = pNew;
    return true;
}
bool delet_list(Node *pHead, int pos, int* pval)//將pos位置的值刪除
{
    int i = 0;
    Node* p = pHead;
    while (p->pNext != NULL&&i < pos - 1)
    {
        p = p->pNext;
        i++;
    }
    if (i>pos - 1 || p->pNext == NULL)
        return false;

    Node *q = p->pNext;
    *pval = q->data;
    p->pNext = p->pNext->pNext;
    delete q;
    return true;
}

  我們先來看下單鏈表的建立，其實就相當於一個數組的初始化。其演算法思路如下：

1. 宣告一結點 p 和長度變數 len
2. 初始化一空連結串列 L
3. 讓 L 的頭結點的指標指向 NULL ，即建立一個帶頭結點的單鏈表i
4. 迴圈:
   生成一新結點賦值給 p;
   隨機生成一數字賦值給 p 的資料域 p->data；
   將 p 插入到連結串列中。

  要輸出整個連結串列則先讀取頭結點下個結點資料域中的資料元素，再讀取指標域中的地址，將指標指向下一個結點。

#include<iostream>
#include "Node.h"
using namespace std;

Node * create_list();
void traverse_list(Node *pHead);
bool is_empty_list(Node *pHead);
int length_list(Node *pHead);
bool insert_list(Node *pHead,int pos,int val);
bool delet_list(Node *pHead,int pos,int* pval);
void sort_list(Node *pHead);

int main()
{
    Node* pHead = NULL;
    int val;
    pHead = create_list();
    system("pause");
    return 0;
}

  在VS下執行結果如下：

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

1. 宣告一結點 p 指向連結串列第一個結點，初始化 j 從 1 開始
2. 當j<i$j<i$時，就遍歷連結串列，讓 p 的指標向後移動，不斷指向下一結點， j 累加 1
3. 若到鏈衰末尾 p 為空，則說明第 i 個元素不存在
4. 否則查詢成功，在系統中生成一個空結點 s;
5. 將資料元素 e 賦值給s->data ;
6. 單鏈表的插入標準語句 s->next=p->next.; p->next=s ;
7. 返回成功。

#include<iostream>
#include "Node.h"
using namespace std;

Node * create_list();
void traverse_list(Node *pHead);
bool is_empty_list(Node *pHead);
int length_list(Node *pHead);
bool insert_list(Node *pHead,int pos,int val);
bool delet_list(Node *pHead,int pos,int* pval);
void sort_list(Node *pHead);
int main()
{
    Node* pHead = NULL;
    int val;
    pHead = create_list();
    insert_list(pHead, 2, 9);
    traverse_list(pHead);
    system("pause");
    return 0;
}

  在VS下執行結果如下：

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

1. 宣告一結點 p 指向連結串列第一個結點， 初始化j 從 1 開始j；
2. 當j<i$j<i$時，就遍歷連結串列，讓 p 的指標向後移動，不斷指向下一結點， j 累加 1；
3. 若到連結串列末尾p 為空，則說明第 i 個元素不存在;
4. 否則查詢成功，將欲刪除的結點 p->next 賦值給q ;
5. 主在連結串列的刪除標準語句 p->next=q->next;
6. 將 q 結點中的資料賦值給e ，作為返回;
7. 釋放q 結點;
8. 返回成功。

#include<iostream>
#include "Node.h"
using namespace std;

Node * create_list();
void traverse_list(Node *pHead);
bool is_empty_list(Node *pHead);
int length_list(Node *pHead);
bool insert_list(Node *pHead,int pos,int val);
bool delet_list(Node *pHead,int pos,int* pval);
void sort_list(Node *pHead);
int main()
{
    Node* pHead = NULL;
    int val;
    pHead = create_list();
    traverse_list(pHead);
    delet_list(pHead, 2, &val);
    cout << "被刪除的資料元素是：" << val << endl;
    traverse_list(pHead);
    system("pause");
    return 0;
}

  在VS下執行結果如下：

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

儲存分配方式

• 順序儲存結構：連續依次儲存。
• 單鏈表：一組任意的儲存單元可以離散儲存。

時間效能

查詢	插入和刪除
順序儲存結構	O(1)	O(n)
單鏈表	O(n)	O(1)

空間效能

• 順序儲存結構：需要預分配儲存空間，分大了浪費，分小了易發生上溢。
• 單鏈表：不需要預分配儲存空間，只要有就可以分配，元素個數也不受限制。

其他的鏈式儲存結構

  下面我們簡單介紹下其他幾種鏈式儲存結構。

靜態連結串列

  靜態連結串列是用陣列描述的連結串列，又叫做遊標實現法。它其實是為了給沒有指標的高階語言設計的一種實現單鏈表能力的方法。

迴圈連結串列

  將單鏈表中終端結點的指標端由空指標改為指向頭結點，就使整個單鏈表形成一個環，這種頭尾相接的單鏈表稱為單迴圈連結串列，簡稱迴圈連結串列 ( circular linked list) 。

雙向連結串列

  雙向連結串列(double linked List) 是在單鏈表的每個結點中，再設定一個指向其前驅結點的指標域。所以在雙向連結串列中的結點都有兩個指標域， 一個指向直接後繼，另一個指向直接前驅。