2. 程式人生 > >資料結構理論基礎-2—線性表

資料結構理論基礎-2—線性表

阿新 • • 發佈：2018-12-21

Table of Contents

線性表

插入操作

刪除操作

靜態連結串列

迴圈連結串列

雙向連結串列

線性表

線性表（List）:零個或多個數據元素的有限序列

用數學語言進行定義，如下：

若將線性表記為（a_{1},...,a_{i-1}, a_{i}, a_{i+1},..., a_{n}），稱 a_{i-1} 是 a_{i} 的直接前驅元素，a_{i+1} 是 a_{i} 的直接後繼元素。當i = 1, 2,...,n-1時， a_{i} 有且僅有一個直接後繼，當 i = 2, 3, ...,n 時， a_{i} 有且僅有一個直接前驅。

線性表的抽象資料型別如下：

ADT 線性表（List）

Data

(數學語言定義)

Operation

InitList（*L）: 初始化操作，建立一個空的線性表L

ListEmpty（L）: 若線性表為空，返回true，否則返回false

ClearList（*L）: 將線性表清空

GetElem（L, i, *e）: 將線性表 L 中的第 i 個位置元素值返回給 e 

LocateElem（L, e）:線上性表 L 中查詢與給定值 e 相等的元素，若查詢成功，返回該元素的序號，否則返回 0 

ListInsert（*L, i, e）:線上性表的第 i 個位置插入元素 e

ListDelete（*L, i, *e）:刪除線性表 L 中第 i 個位置元素，並用 e 返回其值

ListLength（L）:返回線性表 L 的元素個數

線性表的順序儲存結構

線性表的順序儲存結構：指的是用一段地址連續的儲存單元依次儲存線性表的資料元素（可以用C語言中的一維陣列實現）

# define MAXSIAE 20        /*儲存空間初始分配量*/
typedef int ElemType;      /*ElemType型別根據實際情況而定，這裡假設為int*/
type struct{
    Elemtype data[MAXSIZE];/*陣列儲存資料元素，最大值為MAXSIZE*/
    int length;            /*線性表當前長度*/
}SqList;

獲得元素操作

（實現 GetElem（L, i, *e） 操作，時間複雜度為O(1) ）

# define OK  1
# define ERROR 0
# define TURE 1
# define FALSE 0
typedef int Status;

/*操作結果：用e返回L中第i個數據元素的值，i從1開始，與陣列序號相差一個，下同*/
Status GetElem(SqList L, int i, ElemType *e)
{
	if(L.length==0 || i<1 || i>L.length)
		return ERROR;
	*e = L.data[i-1];
	return OK;
}

插入操作

（實現 ListInsert（*L, i, e） 操作，時間複雜度為O(n) ）

插入操作思路：

  • 如果插入位置不合理，丟擲異常
  • 若線性表長度大於陣列長度，丟擲異常或動態增加容量
  • 從最後一個元素向前遍歷到第 i 個位置，分別將它們向後移動一個位置
  • 將要插入的元素 e 填入到位置 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;
}

刪除操作

（實現ListDelete（*L, i, *e） 操作，時間複雜度為O(n) ）

刪除操作的思路：

  • 如果刪除位置不合理，丟擲異常
  • 取出刪除元素
  • 從刪除元素位置開始遍歷到最後一個元素位置，分別將它們向前移動一個位置
  • 表長減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)
	{
		for(k=i; k<L->length; k++)
			L->data[k-1] = L->data[k];
	}
	L->length--;
	return OK;
}

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

優點：

  • 無需為表示表中元素之間的邏輯關係而增加額外的儲存空間
  • 可以快速存取表中任一位置的元素

缺點：

  • 插入和刪除操作需要移動大量元素
  • 當線性表長度變化較大時，難以確定儲存空間的容量
  • 造成儲存空間的“碎片”

線性表的鏈式儲存結構

順序儲存結構的最大缺點是：插入和刪除時需要移動大量元素，原因就在於：順序儲存結構中的相鄰元素，它們的儲存位置也是相鄰的，解決辦法就是：讓儲存位置不再具有任何關係性。

線性表的鏈式儲存結構的特點就是：線性表中的資料元素可在儲存在記憶體未被佔用的任意位置，這些儲存單元可以是連續的，也可以是不連續的。

為了表述資料元素 a_{i} 和其直接後繼元素a_{i+1}之間的邏輯關係，對a_{i}來說，除了儲存其本身的資訊外，還要儲存直接後繼a_{i+1}的儲存位置。我們把儲存資料元素資訊的域稱為資料域，把儲存直接後繼位置的域稱為指標域，指標域中儲存的資訊稱為指標或鏈，資料域和指標域組成元素a_{i}的儲存映像，稱為結點（Node）

n個結點鏈結成一個連結串列，即為線性表的鏈式儲存結構，因為此連結串列的每個結點只包含一個指標域，所以叫單鏈表

單鏈表正是通過每個結點的指標域將線性表的資料元素按其邏輯次序連結在一起

                                                  

      

  

                         

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

從這個結構定義中可知，結點由存放資料元素的資料域和存放後繼結點地址的指標域組成

假設 p 是指向線性表第 i 個元素的指標，則：

                                          

單鏈表的讀取操作

（實現 GetElem（L, i, *e） 操作，時間複雜度為O(n) ）

讀取操作思路：

  1. 宣告一個結點 p 指向連結串列第一個結點，初始化 j 從1開始
  2. 當 j < i 時，就遍歷連結串列，讓 p 的指標向後移動，j++
  3. 若到連結串列末尾 p 為空，則說明第 i 個元素不存在
  4. 否則查詢成功，返回結點 p 的資料
/*操作結果：用e返回L中第i個數據元素的值*/
Status GetElem(LinkList L, int i, ElemType *e)
{
	int j;
	LinkList p; 	/*宣告一個結點p*/
	p = L->next;	/*讓p指向連結串列L的第一個結點*/
	j = 1;			/*j為計數器*/
	while(p && j<i) /*p不為空或計數器j還沒有等於i時，迴圈繼續*/
	{
		p = p->next; 
		j++;
	}
	if(!p || j>i)
		return ERROR;
	*e = p->data;
	return OK;
}

單鏈表的插入

       

由圖可知，根本不用移動其他結點，只需要：

s -> next = p -> next;    p -> next = s; （注意，兩句不能顛倒！！）

既是：讓 p 的原後繼結點改成為 s 的後繼結點，再把 s 結點變成 p 的新後繼結點

插入操作（實現 ListInsert（*L, i, e） 操作，時間複雜度為O(n) ）

插入操作思路：

  1. 宣告一個結點 p 指向連結串列第一個結點，初始化 j 從1開始
  2. 當 j < i 時，就遍歷連結串列，讓 p 的指標向後移動，j++
  3. 若到連結串列末尾 p 為空，則說明第 i 個元素不存在
  4. 否則查詢成功，在系統中生成一個空結點s
  5. 將資料元素 e 賦值給 s->data
  6. 單鏈表的插入標準語句 s -> next = p -> next;  p -> next = s;
  7. 返回成功
/*操作結果：在 L 中第 i 個位置之前插入新的元素 e, L 的長度加 1*/
Status ListInsert(LinkList L, int i, ElemType e)
{
	int j;
	LinkList 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))  /* C語言中的 malloc 函式作用是生成一個新的結點，其型別                                                
                              和 Node 一致，實質就是在記憶體中找一塊空地，用來存放 e 資料 s 結點*/
        s->data = e;
        s->next = p->next;
        p->next = s;
	return OK;
}

單鏈表的刪除

                                          

實際上就是一步，p->next = p->next->next （也就是讓 p 的後繼的後繼結點改成 p 的後繼結點）：

如果用 q 來取代 p->next，則

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

刪除操作（實現 ListDelete（*L, i, *e） 操作，時間複雜度為O(n) ）

刪除操作思路：

  1. 宣告一個結點 p 指向連結串列第一個結點，初始化 j 從1開始
  2. 當 j < i 時，就遍歷連結串列，讓 p 的指標向後移動，j++
  3. 若到連結串列末尾 p 為空，則說明第 i 個元素不存在
  4. 否則查詢成功，將欲刪除的結點 p-next 賦值給 q
  5. 單鏈表的刪除標準語句   p -> next = q -> next;
  6. 將 q 結點中的資料賦值給 e 
  7. 釋放 q 結點
  8. 返回成功
/*操作結果：刪除 L 中第 i 資料元素，並用 e 返回其值, L 的長度減 1*/
Status ListDelete(LinkList L, int i, ElemType *e)
{
	int j;
	LinkList p, q; 	
	p = *L;	
	j = 1;			
	while(p->next && j<i) /* 尋找第 i 個元素*/
	{
		p = p->next; 
		j++;
	}
	if(!(p->next) || j>i)
		return ERROR;  /* 第 i 個元素不存在 */
	q = p->next;
        p->next = q->next;
        free(q);
	return OK;
}

分析可發現，單鏈表的插入和刪除操作看起來並不比順序儲存結構簡單，複雜度也都是 O(n)。其實不然，當我們想從第 i 個位置插入10個元素時，對順序儲存結構來說，每次插入都要移動 n-i 個元素，每次都是O(n)，而單鏈表只需要找到第 i 個位置的指標（複雜度為O(n) ），之後插入的操作都是O(1)。對於插入或刪除資料越頻繁的操作，單鏈表的優勢越明顯。

單鏈表的整表建立

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

單鏈表整表建立的演算法思路：

  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 個元素的值，建立帶表頭結點的單鏈表線性表L（尾插法）*/
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;  /* 表示當前連結串列結束 */
}

單鏈表的整表刪除

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

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

        將下一結點賦值給 q;

        釋放 p

        將 q 賦值給 p

/* 將 L 重置為空表*/
void ClearList(LinkList *L)
{
    LinkList p, q;
    p = (*L)->next;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    (*L)->next = NULL;  /*頭節點指標域為空*/
    return OK;
}

靜態連結串列

靜態連結串列是指當某種語言沒有指標能力的時候，人們想用陣列來代替指標，來描述連結串列。讓陣列的元素由兩個資料域 data 和 cur 組成，資料域 data 用來存放資料元素，遊標 cur 相當於 next 指標，存放該元素的後繼在陣列中的下標。

/* 線性表的靜態連結串列儲存結構 */
#define MAXSIZE 1000  /* 假設連結串列的最大長度是1000 */
typedef struct
{
    ElemType data;
    int cur;  /* 遊標（cursor）為 0 時表示無指向 */
}Component, StaticLinkList[MAXSIZE];

        

如上圖所示，我們對陣列的第一個和最後一個元素作為特殊元素處理，不存放資料。陣列第一個元素的 cur 存放備用連結串列（未被使用的資料元素）的第一個結點的下標，陣列最後一個元素的 cur 存放第一個有數值的元素的下標。程式碼如下：

Status InitList(StaticLinkList space)
{
    int i;
    for(i=0; i<MAXSIZE-1; i++)
        space[i].cur = i+1;
    space[MAXSIZE-1].cur = 0;
    return OK;
}

假設把 甲 乙 丁等資料存入靜態連結串列的話，則如下圖所示：

                             

靜態連結串列的插入操作

靜態連結串列中要解決的是：如何用靜態模擬動態連結串列結構的儲存空間的分配，需要時申請（malloc（）函式），無用時釋放（free（）函式）

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

int Malloc_SLL(StaticLinkList space)
{
    int i = space[0].cur;  /* i 就是第一個備用空閒的下標 */
    if(space[0].cur)
        space[0].cur = space[i].cur;  /* 由於拿出一個分量來使用了，所以就得把它的下一個分量用來 
                                         做備用 */
    return i;
}

這段程式碼，拿上圖 甲 乙 丁的例子來說，下標為7的分量準備要使用了，就得有接替者，所以就把分量 7 的 cur 值賦值給頭元素，也就是把 8 給 space[0].cur，實現類似malloc（）函式的使用。

那麼如何把 丙 存放在 乙 和 丁 中間？

              

如圖所示，只需要把 乙 放在空閒分量7的位置，把原來的 乙.cur = 3  改為  丙.cur = 3， 乙.cur = 7.

/* 在 L 中第 i 個元素之前插入新的資料元素 e */
Status ListInsert(StaticLinkList L, int i, ElemType e)
{
    int j, k, l;
    k = MAXSIZE - 1;
    if(i<1 || i>ListLength(L) + 1)
        return ERROR;
    j = Malloc_SSL(L);  /* 獲得空閒分量的下標 */
    if(j)
    {
        L[j].data = e;  /* 將資料賦值給此分量的data */
        for(l=1; l<i-1; l++)  /* 找到第 i 個元素之前的位置 */
            k = L[k].cur;
        L[j].cur = L[k].cur;  /* 把第 i 個元素之前的 cur 賦值給新元素的cur,即 丙.cur=3 */
        l[k].cur = j;  /* 把新元素的下標賦值給第 i 個元素之前元素的cur,即 乙.cur=7 */
        return OK;
    }
}

靜態連結串列的刪除操作

如何刪除連結串列中的 “甲”？

             

意思就是，刪除了 甲 之後，位置空了出來，如果之後有插入操作的話，優先考慮這裡

/* 刪除在L中第 i 個數據元素 e */
Status ListDelete(StaticLinkList L, int i)
{
    int j, k;
    if(i<1 || i>ListLength(L))
        return ERROR;
    k = MAXSIZE - 1;
    for(j=1; j<i-1; j++)
        k = L[k].cur;
    j = L[k].cur;
    L[k].cur = L[j].cur;
    Free_SSL(L, j);
    return OK;
}

/* 將下標為 k 的空閒結點回收到備用連結串列 */
void Free_SSL(StaticLinkList space, int k)
{
    space[k].cur = space[0].cur;  /* 把第一個元素 cur 值賦給要刪除的分量cur */
    space[0].cur = k;  /* 把要刪除的分量下標賦值給第一個元素的cur */
}

Free_SLL()函式中的兩句，也就是 space[1].cur = space[0].cur = 8;   space[0].cur = k = 1;看刪除前後兩張圖的變化就能理解。

靜態列表用的較少，優缺點如下：

優點：

    在插入和刪除操作時，只需要修改遊標，不需要移動元素。

缺點：

    沒有解決連續儲存分配帶來的表長難以確定的問題

    失去了順序儲存結構隨機存取的特性

迴圈連結串列

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

迴圈列表解決了一個很麻煩的問題：如何從當中一個結點出發，訪問到連結串列的全部結點

           

雙向連結串列

雙向連結串列：是在單鏈表的每個結點中，再設定一個指向其前驅結點的指標域。

/* 線性表的雙向連結串列儲存結構 */
typedef struct DulNode
{
    ElemType data;
    struct DulNode *prior;  /* 直接前驅指標 */
    struct DulNode *next;  /* 直接後繼指標 */
}DulNode *DuLinkList;

  

雙向連結串列的插入和刪除操作並不複雜，只是順序比較重要。

     

/* 插入順序 */
s -> prior = p;            /* 把 p 賦值給 s 的前驅 */
s -> next = p -> next;     /* 把 p->next 賦值給 s 的後繼 */   
p ->next -> prior = s;    /* 把 s 賦值給 p->next 的前驅 */
p -> next = s;            /* 把 s 賦值給 p 的後繼 */

/* 刪除順序 */
p -> prior ->next = p -> next;    /* 把 p->next 賦值給 p->prior的後繼 */
p -> next -> prior = p -> prior;  /* 把 p->prior 賦值給 p->next的前驅 */   
free(p);

相關推薦

資料結構理論基礎-2—線性表

Table of Contents 線性表 插入操作 刪除操作 靜態連結串列 迴圈連結串列 雙向連結串列 線性表 線性表（List）:零個或多個數據元素的有限序列 用數學語言進行定義，如下： 若將線性表記為（），稱  是 

【資料結構】天勤線性表思考題2.1

有N個個位正整數存放在int整型陣列A中，N定義為已經定義的常亮N<=9，陣列長度為N，另給一個int型變數i，要求只用上述變數，寫一個演算法，找出N個整數中的最小者，並且要求不能破壞陣列資料。 思路：i作為變數，這個變數的百位用於儲存最小值地址，十位用來儲存最小值，

資料結構學習筆記之線性表

一、概念 什麼是線性表呢？ 一個簡單的理解如下： 線性表是由稱為元素（Element）的資料項組成的一種有限且有序的序列 其中，這裡有一個需要注意的地方： 有序是指線性表中的每個元素都有自己的位置，而不是指線性表中的元素按某種順序排列 二、抽象資料型別定義 要給資料結構定

大話資料結構（一）——線性表順序儲存結構的java實現

    在看《大話資料結構》的時候，裡面詼諧的語言和講解吸引了我，但是這本書是用C來實現的，但是作為一個手擼java的人就想著用java來實現一下這些資料結構，於是就有了這些大話資料結構之java實現。哈哈，感覺這樣會讓自己的理解加深不少。 &n

資料結構之查詢-基於線性表的查詢法

基於線性表的查詢法 順序查詢 演算法思想 用所給的元素與列表的中的各個元素進行比較，若相等返回索引，否則返回錯誤資訊。 假設列表長度為$n$那麼查詢第$i$個元素時需進行$n-i+1$次比較，即$C_i=n-i+1$,又假設查詢每個資料元素的概率相等，即$P_i =1/n$,則順序查詢成功的平均查詢長

【資料結構】1-1 線性表

//單鏈表.cpp #include"LinkList.h" #include<iostream> template<class T> LinkList<T>::LinkList() { head = new Node<T>; head-&

【資料結構與演算法】線性表——刪除重複元素

線性表是一種隨機存取的結構，和連結串列不同，連結串列順序存取的結構。但是，線性表是一種順序儲存的結構，而連結串列是鏈式儲存結構。兩者都是線性的，但區別不同。   進入主題： 1.假如有一串資料元素，要求刪除其中的重複元素。 首先想到的是用兩層迴圈，第一層從第一個元素開始，第

資料結構（概述、線性表）

資料結構 本文大部分內容整理自程傑老師的《大話資料結構》 一、資料結構概述 分類： ①邏輯結構：面向問題的結構，主要是思維上的認知 1.集合結構 唯一的關係是大家都在一個集合內 2.線性結構 一對一 3.樹形結構 一對多 4.圖

資料結構那點事--線性表（連結串列）

#include<iostream> #include<stdlib.h> using namespace std; //鏈式線性表的儲存結構 #define OK 1 #define ERROR 0 #define TRUE 1 #de

PTA-資料結構 求鏈式線性表的倒數第K項

7-24 求鏈式線性表的倒數第K項 （20 分） 給定一系列正整數，請設計一個儘可能高效的演算法，查詢倒數第K個位置上的數字。 輸入格式: 輸入首先給出一個正整數K，隨後是若干正整數，最後以一個負整數表示結尾（該負數不算在序列內，不要處理）。 輸出格式: 輸出倒數第

資料結構那點事--線性表（迴圈列表）

#include<iostream> using namespace std; typedef struct DulNode { ElemType data; struct DuLNode *prior;//直接前驅結點 struct DuLN

資料結構（一）線性表

特徵性質   線性結構 （1）唯一一個第一，唯一一個最後 （2）除第一個外均有唯一後繼，除最後一個均有唯一前驅 分為： 順序儲存線性表 優點 查詢快       缺點 插入刪除慢  可以陣列實現   資料的擴容  動態陣列 無序陣列的應用： 排序 氣泡

資料結構與演算法之線性表相關程式

1.從有序表中刪除所有值重複的元素，使所有值均不同 #include<stdio.h> #define MaxSize 50 #define Elemtype int typedef struct{ Elemtype data[MaxSize]; int

資料結構實驗一：線性表的基本操作

// 186658-S181-李雙源.cpp : 定義控制檯應用程式的入口點。 //時間 2018-10-27 //內容：線性表的基本操作 #include "stdafx.h" #include <iostream> #include<s

資料結構理論基礎-3—棧與佇列

棧 棧（stack）:是限定僅在表尾進行插入和刪除操作的線性表。（注意，表尾是棧頂，不是棧底） 允許插入和刪除的一端稱為棧頂（top），另一端稱為棧底（bottom），棧又稱為後進先出（Last In First Out），簡稱LIFO結構              

資料結構學習筆記-03-線性表及其實現

線性表的順序儲存實現 typedef struct LNode *list; struct LNode { ElementType Data[MAXSIZE]; int Last; }; struct LNode L; List Ptrl; 初始化： List MakeE

資料結構（5）線性表之連結串列C++實現帶頭結點的單鏈表合併

題目 如何將有序連結串列合併成有序連結串列 假設頭指標為La和Lb的單鏈表分別為線性表LA和LB的儲存結構,現要歸併La和Lb得到單鏈表Lc。 思路點撥 按照第三篇文章的思想，需要設立三個指標pa，pb和pc，其中pa和

資料結構筆記二：線性表

1. 線性表的邏輯結構 2. 線性表包括的基本操作 3. 線性表的順序儲存結構 4. 線性表的鏈式儲存結構

資料結構（二）:線性表的使用原則以及連結串列的應用-稀疏矩陣的三元組表示

下面先對沒有介紹的連結串列中的雙鏈表進行介紹，並通過稀疏矩陣的三元組的鏈式結構來深入理解較為複雜的連結串列儲存結構。最後對三次博文所講述的內容進行梳理，以幫助在實際應用中選擇最合適的儲存結構：順序表

資料結構與演算法之線性表簡單定義（順序結構儲存查，增，刪）

線性表（List） 由零個或多個數據元素組成的有限序列，它是一個序列，也就是說元素之間是有個先來後到的，若元素存在多個，則第一個元素無前驅，最後一個元素無後繼，其他元素有且只有一個前驅和後繼，另外，線性表強調是有限的，事實上無論計算機發展多強大，它處理的元素都是有限的。