線性表是平時一直會用到的資料結構，像python裡面的list這種高階資料結構，其實也是對這種底層結構的封裝。

這篇文章寫了整整4天........

線性表的儲存結構主要分兩大類，一類一類來看。

在這之前，先用虛擬碼來形容一下線性表擁有的基本功能

1 ：順序儲存結構

聽名字就知道，這是按照順序來排的，簡單來說，就是在用順序儲存結構來建立線性表的時候，他是在記憶體裡面先申請一塊空地

然後，所有的相同型別的資料元素按照順序，放進去，並且，在記憶體中的存放，也是連續的！

也就是打個比方a,b,c三個元素的記憶體地址，如果按照順序儲存結構的話就會是0x00001 ---> 0x00002 ---> 0x00003

另外，順序儲存的時候，由於是先申請記憶體空間，再放入線性表，所以，正常來說，陣列長度(也就是申請的空間大小)是大於等於線性表長度的

其次，陣列內元素的下標，是要比第i個元素的i少一位的，如下圖.

概括一下，線性表的儲存結構可以用以下程式碼來抽象表示

#define MAXSIZE 20 /* 儲存空間初始分配量 */

typedef struct
{
	ElemType data[MAXSIZE];        /* 陣列，儲存資料元素 */
	int length;                                /* 線性表當前長度 */
}SqList;

每個資料元素，其實在記憶體中都有他的固定地址的

然後由於順序線性表的都是連續固定的，所以根據每種元素的資料型別的不同，你可以看出後面元素的不同記憶體地址

假設我們存放的是整數int，他每個元素要佔用c個空間，那麼我們用LOC(a)來表示a這個元素的記憶體地址的話

那麼LOC(ai+1)=LOC(ai)+C

那麼LOC(ai)可以根據a1的LOC來推算出他的記憶體地址LOC(ai)=LOC(a1)+(i-1)*c

所以，由於記憶體地址都是連續的，所以你完全可以通過第一個元素就知道其中第i個元素的值，所以，讀取或存放的時間複雜度為O(1)

1 順序儲存線性表的元素獲取

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;          /* Status是函式的型別,其值是函式結果狀態程式碼，如OK等 */

/* 初始條件: 順序線性表L已經存在，1≤i≤ListLength(L) */

/* 操作結果: 用e返回L 中第i個數據元素的值 */

Status GetElem(SqList L,int i,ElemType *e)   /* 這裡等於是定義GetElem返回時整型 ，這句函式其實等於int GetElem  */
{
    if(L.length==0 || i<1 || i>L.length)
            return ERROR;
    *e=L.data[i-1];

    return OK;
}
 

如果陣列長度為0 或 i小於1 或 i 大於陣列長度最大位的後一位，直接返回ERROR

否則，代表能讀到這個數，則給 *e 賦值，值為陣列資料的第i-1下標位的數值，並返回OK

2 順序儲存線性表的元素插入

這個原理和插隊是一樣的，比如一共10個人的隊伍，你認識第4個人，你讓他給你插下隊，那你認識的人就變成第5個了，你變成了第4個，佇列長度要加1

/* 初始條件：順序線性表L已存在,1≤i≤ListLength(L)， */
/* 操作結果：在L中第i個位置之前插入新的資料元素e，L的長度加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--)  /* 將要插入位置之後的資料元素向後移動一位,k>=i-1等於是說明，當新元素的下標k，越過i-1時 */
			L->data[k+1]=L->data[k]; /*每次歷遍都把當前下標位k的元素向後移動一位*/
	}
	L->data[i-1]=e;          /* 將新元素插入 */
	L->length++;

	return OK;
}

這裡注意，溫習一下，指標訪問結構體成員的方法是L->length，如果是結構體變數訪問成員的話，是 xxx.length

3 順序儲存線性表的元素刪除

/* 初始條件：順序線性表L已存在，1≤i≤ListLength(L) */
/* 操作結果：刪除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];                /* 用第i個元素給e賦值 */
    if (i<L->length)                /* 如果刪除不是最後位置 */
    {
        for(k=i;k<L->length;k++)/* 將刪除位置後繼元素前移 */  
			L->data[k-1]=L->data[k];  /* 通過元素下標前移元素 */
    }
    L->length--;
    return OK;
}

通過插入元素和刪除元素，我們可以看到，需要對元素進行操作的話，最壞情況下，是每個元素都要移動一下。

所以這時候的時間複雜度是O(n)

至此可以看出順序儲存結構線性表的優缺點了

2.鏈式儲存結構線性表

鏈式儲存結構和順序結構正好相反，他的元素存放，不是排排坐吃果果般連續的，而是分散的，說不定是記憶體地址0x00001------>0x00013------>0x00022

但是，前一個元素，會知道後一個元素的記憶體地址，他是如何知道的呢

這是因為，鏈式儲存結構的元素，不光光有資料值，他還有指標域，指向後一個元素

這樣，我們把資料域+指標域稱為結點Node

每個結點只包含一個指標域的，叫做單鏈表

作為單鏈表來說，總得有一個指向第一個元素結點的東東，這裡，叫做頭指標，單鏈表裡面必須有的東西。

頭指標只有指標域，他指向的是第一個結點的地址.

而相對的，最後一個元素結點的指標域，指向的結果是NULL

另外，有時我們還會在頭指標和第一個元素結點的中間，新增一個頭結點，這個結點的資料域可以不存放東西，也可以存放如陣列長度啊這些的資訊，他的指標域指向第一個元素結點。

然後來看下頭指標和頭結點的區別

這樣，總結一下儲存示意圖

其實對於連結串列來說，他都是由一個一個結點組成的

所以，我們可以用結構指標來表示連結串列

typedef struct Node
{
    ElemType data;            /* 資料域 */
    struct Node *next;        /* 指標域 */
}Node;                        /* 取個別名Node，方便操作 */
typedef struct Node *LinkList; /* 定義LinkList，指向結構體Node的指標 */

假設我們有個指標p，指向連結串列的第i個結點，那麼p->data就表示資料域，p->next就表示指標域

p->next指向的是下一個結點，如果要指向下一個結點的資料域，則是表示成p->next->data

1 單鏈表的讀取

對於單鏈表來說，你要獲取一個元素，你必須從頭開始歷遍

/* 初始條件：順序線性表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;		/*  j為計數器 */
	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;
}

這裡需要注意一下，上一個章節裡面講順序儲存結構線性表的時候，SqList是一個結構體別名, 他定義生成的物件是例項變數

而這個章節的LinkList，是一個指向結構體Node的指標！他定義生成的物件是一個指標！

還有p=L->next不是將L的下一個結點賦值給p，而是將p指向L的下一個結點，p還是指標型別！

上面這個獲取元素的程式碼，他在 j 未達到 i 的過程中，迴圈將p結點向後移動，他將在  j=i 的時候, 將當前p的data，也就是儲存的數值，賦值給 *e

最後return Ok

而通過連結串列的結構我們可以知道，只有上一個結點才知道下一個結點在哪裡，所以，當你需要知道一個結點的值的時候，只能從開頭一個一個歷遍

所以，他的時間複雜度是O(n)

2 單鏈表的插入

事物總有兩面性，連結串列的讀取的時間複雜度是O(n) ，那肯定也有優點，來看看單鏈表的插入

簡單來說，連結串列的插入就是，把新結點的後繼指標指向原來這個位置的結點，再把前一個結點的後繼指標指向新結點

先後次序可以概括為  s->next = p->next ，然後 p->next = s

這裡得記住，千萬不能顛倒次序，如果你先將p->next=s進行了賦值，那後面s->next就等於他s自己了，等於斷鏈了。

    

/* 初始條件：順序線性表L已存在,1≤i≤ListLength(L)， */
/* 操作結果：在L中第i個位置之前插入新的資料元素e，L的長度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{ 
	int j;
	LinkList p,s;
	p = *L;                /* p還是指標，指向第一個結點 */
	j = 1;
	while (p && j < i)     /* 尋找第i個結點 */
	{
		p = p->next;   /* 這句很重要，他並不是說p是p的下一個結點，而是說，p從指向當前結點，變成指向下一結點 */
		++j;
	} 
	if (!p || j > i) 
		return ERROR;   /* 第i個元素不存在 */
	s = (LinkList)malloc(sizeof(Node));  /*  生成新結點(C語言標準函式) */
	s->data = e;  
	s->next = p->next;      /* 將p的後繼結點賦值給s的後繼  */
	p->next = s;          /* 將s賦值給p的後繼 */
	return OK;
}

這段程式碼再附加解釋一下

LinkList p,s是定義了2個結構體指標p和s

並通過p=*L的語句，讓p指第一個結點, 具體意思是，傳入的是頭指標本身的記憶體地址，然後再用 * 解引用，解出來的就是頭指標的記憶體地址

注意一下，這裡的LinkList *L ，涉及到了C語言裡，函式引數傳遞的規則.

*L表示地址傳遞，雖然在C裡面沒有真正意義上的地址傳遞。

所以這個過程應該是，傳入L實參的地址，即傳入形參*L的值為  &L (是指標L的本身記憶體地址)，也就是要操作指標L的地址的話，需要用一個二級指標來做 * 操作

另外，我理解，這個L其實是一個頭指標，他的指標域是指向第一個結點的

這部分會比較難理解，自己畫了個圖

從上面的結構圖可以看出，p=*L 就等於指標L的地址，在第一輪歷遍的時候，頭指標和p是重合的，但是在後面的歷遍中，p會不斷地向後移動

為什麼不用值傳遞！因為，值傳遞不改變實際引數，而地址傳遞是在記憶體地址上進行操作的，所以改變實際引數的！

而這裡插入元素，是需要改變原來L連結串列的結構的!!

當開始迴圈的第一遍時，p 就指向第一個結點，並且在p && j<i 的情況下，p=p->next，也就是p指標的指向，從當前位置後移一位

3 單鏈表的元素刪除

刪除和插入沒啥大的結構上區別，也即是把前驅指標和後繼指標進行調整，注意順序

/* 初始條件：順序線性表L已存在，1≤i≤ListLength(L) */
/* 操作結果：刪除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;			/* 將q的後繼賦值給p的後繼 */
	*e = q->data;               /* 將q結點中的資料給e */
	free(q);                    /* 讓系統回收此結點，釋放記憶體 */
	return OK;
}

4 單鏈表的整表建立

連結串列的建立實際上是一個動態的過程，因為每次多加一個元素，他的記憶體空間才會擴充一次，即用即擴充套件，所以他需要用到malloc

另外新建連結串列也可以有2種方法，頭插法和尾插法

先來看頭插法

/*  隨機產生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;						/*  插入到表頭 */
	}
}

沒啥好多說的，有一句需要著重強調

*L = (LinkList)malloc(sizeof(Node))

這句的意思是什麼？(LinkList)malloc(sizeof(Node)) 返回的是一個指標變數！！！是指向一個結點(也就是頭結點)的指標！！！

而這個等式，讓*L這個指標，被引向了指向頭結點的指標，在此刻等同於頭結點的指標

為什麼說是建立了一個頭結點，是因為(*L)->next = NULL

接著是尾插法，這個屬於一般比較正常的思路，從尾部插入

/*  隨機產生n個元素的值，建立帶表頭結點的單鏈線性表L（尾插法） */
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;           /*  隨機生成100以內的數字 */
		r->next=p;                        /* 將表尾終端結點的指標指向新結點 */
		r = p;                            /* 將當前的新結點定義為表尾終端結點 */
	}
	r->next = NULL;                       /* 表示當前連結串列結束 */
}

這裡又有一個比較重要的語句  r=*L

這裡 *L 是指向頭結點的指標，但是L是代表整個線性表，他會隨著n的增大而增大

r是指向結點的指標，但是他會在每次歷遍，指向不同的結點

為什麼要這樣區分呢？因為連結串列的長度的計算，是按照從*L這個頭結點開始，經過n次歷遍，直到最後一個結點的next為NULL的時候才停止。

也就是說,  *L必須停留在起始位置

而 r 在程式剛開始的時候和*L是重合的。只是在後面的歷遍過程中，逐漸分開了。

r 在歷遍過程中，始終為指向最後一個節點的指標。

兩個語句需要補充理解：

r->next = p    將r 和新的結點p進行連線

r = p ，將當前指向 r 的指標 引向 p ,也就是當前最後一個結點，等於是重新整理了 r

這裡補充一下計算連結串列長度的函式，就可以看到，為什麼*L要停留在頭部

/* 初始條件：順序線性表L已存在。操作結果：返回L中資料元素個數 */
int ListLength(LinkList L)
{
    int i=0;
    LinkList p=L->next; /* p指向第一個結點 */
    while(p)                        
    {
        i++;
        p=p->next;
    }
    return i;
}

計算過程從L開始歷遍，每次歷遍計數器加1 ，最後返回的是計數器數字

5 單鏈表的整表刪除

他關鍵也是用到指標的移動和free函式

/* 初始條件：順序線性表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;
}

從前往後依次free掉結點，組後把頭結點的next設為NULL，即置空！

這樣，兩種儲存結構的線性表，就基本是這樣，下一篇再寫點迴圈連結串列和雙向連結串列.