1.單鏈表的讀取

獲取連結串列第i個數據的演算法思路：
1. 宣告一個指標p指向連結串列的第一個結點，初始化j從1開始；
2. 當j< i 時，遍歷連結串列，讓p的指標向後移動，不斷指向下一結點，j累加1；
3. 若到連結串列末尾p為空，說明第i個元素不存在；
4. 否則查詢成功，返回結點p的資料。

/*初始條件：順序線性表L已存在，1≤i≤ListLength(L)*/
/*操作結果： 用e返回L中第i個數據元素的值*/
Status GetElem(LinkList L,int i ,ElemType *e)
{
int j;
LinkList p; /*宣告一指標p*/
p = L->
 
next; /*讓p指向連結串列L的第一個結點*/
j = 1;  /*計數器*/
while(p && j<i) /*當p不為空或者j還沒有大於等於i時，迴圈繼續*/
    {
    p = p->next;  /*讓p指向下一個結點*/
    ++j;
    }
if (!p || j>i)
    return ERROR; /*第i個元素不存在*/
*e = p->data;  /*取出第i個結點的資料*/
return OK;
}

由於單鏈表的結構中沒有定義表長，所以不能事先知道要迴圈多少次，因此不方便用for迴圈來控制迴圈。

2.單鏈表的插入

插入過程，如下圖所示：

只需讓s->next 和p->next的指標做一點改變即可。

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

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

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

/*初始條件：順序線性表L已存在，1≤i≤ListLength(L)*/
/*操作結果：在L中第i個位置之前插入新的資料元素e，L的長度加1*/
Status ListInsert(LinkList *L,int i ,ElemType e)
{
int j;
LintList p,s; 
p = *L;
j = 1;
while (p && j<i) /*尋找第i個結點*/
    {
    p = p->next;
    ++j;
    }
if (!p || j >i)
    return ERROR;  /*第i個元素不存在*/

s = (LinkList)malloc(sizeof(Node)); /*生成新的結點*/
s->data = e;
s->next = p->next;  /*將p的後繼結點賦值給s的後繼*/
p->next = s;  /*將s賦值給p的後繼*/
return OK;
}

3.單鏈表的刪除

實際上就是一步，p->next = p->next->next. 用p來取代p->next;

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

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

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

#include <stdio.h>
#define ERROR 0
#define OK 1
Status ListDelete(LinkList *L,int i ,ElemType *e)
{
int j;
LinkList p,q;
p = *L;
j = 1;
while(p->next && j <i)
    {
    p = p->next;
    ++j;
    }
if(!(p->next) || j>i)
    return ERROR;
q = p->next;
p->next = q->next;
*e = q->data;
free(q);
return OK;
}

對於基本的插入與刪除操作，它們其實都是兩部分組成：

1.遍歷查詢第i個結點；
2.插入和刪除結點。

4.單鏈表的整表建立

單鏈表是一種動態結構。
對於每個連結串列來說，它所佔用的空間大小和位置是不需要預先分配的。
所以建立單鏈表的過程，就是從“空表”的初始狀態，一次建立各元素結點，並插入連結串列中、

單鏈表的整表建立的演算法思路：
（頭插法）
1.宣告以指標p和計數器變數i；
2.建立一個空連結串列L；
3.讓L的頭結點的指標指向NULL；
4.迴圈：

• 生成以新結點賦值給p
• 隨機生成以數字賦值給p->data;
• 將p插入到頭結點與前一新結點之間。

頭插法，示意圖：

/*隨機產生n個元素的值，建立帶表頭結點的單鏈線性表L（頭插法）*/
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;  /*插入到表頭*/
    }
}

尾插法：把每次新結點都插在終端結點的後面

程式碼：

/*隨機產生n個元素的值，建立帶表頭結點的單鏈線性表（尾插法）*/
void CreateListTail(LinkList *L,int n)
｛
LinkList p,r;
int i;
srand(time(0)); 
*L = (LinkList)malloc(sizeof(Node)) 
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;   /*表示當前連結串列結束*/
｝

5.單鏈表的整表刪除

當我們不打算使用這個單鏈表時候，我們需要把它銷燬，其實就是在記憶體中將它釋放掉。

思路：
1.宣告結點p和q；
2.將第一個結點賦值給p；
3.迴圈：

• 將下一結點賦值給q；
• 釋放p；

/*初始條件：順序線性表L已存在，操作結果：將L重置為空表*/
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;
}

6.總結

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

時間效能

順序儲存結構： 查詢為O(1)，因其是隨機存取結構；插入與刪除需要平均移動表長一半的元素，故為O(n);

單鏈表：查詢為O(n)，查詢演算法的時間複雜度取決於i的位置，當i=1時，則不需要遍歷，第一個就取出資料了，而當i=n時則遍歷n-1次才可以。因此最壞情況為O(n);單鏈表在確定出某位置的指標後，插入和刪除時間僅為O(1)；

空間效能

順序儲存結構：需要預分配儲存空間；

單鏈表：不需要分配儲存空間，只要有就可以分配，元素個數也不受限制。

• 若線性表需要頻繁查詢，很少進行插入與刪除操作時，宜採用順序儲存結構；若需要頻繁插入和刪除時，宜採用單鏈表結構。
• 當線性表中的元素個數變化較大或未知時，最好使用單鏈表。如果實現知道線性表的大致長度則使用順序儲存結構效率會高很多。