1、順序儲存結構（如陣列）

定義：

#define MAXSIZE 20
typedef struct{
	int data[MAXSIZE]; //假設這裡是整型
	int length;  //線性表長度
};

讀取其中某個元素：假設線性順序表已存在，讀取其中第i個元素，其值返回到e中

#define ERROR 0
#define OK 1   //定義返回狀態
int GetElem(Squlist L, int i, int *e){
	if (L.length == 0 || i<1 || i>L.length)  //該元素不存在或者超出表範圍或者表為空則讀取失敗
		return ERROR;
	*e = L.data[i - 1];
	return OK;  //讀取成功
};
 

int ListInsert(Squlist *L, int i, int e){
	int k;
	if (L->length == MAXSIZE) //表格是否滿
		return ERROR;
	if (i<1 ||i>length+1)  //插入i不在範圍內
		return ERROR;
	if (i <= L->length)
	{
		for (k = length - 1; k >= i - 1; k--) 
			L->data[k + 1] = L->data[k];
	}
	   L->data[i] = e;
           length++;
	   return OK;
	
}；
 

int ListDelete(Squlist *L, int i, int *e){
	int k;
	if (L->length == 0)      //表格為空
		return ERROR;
	if (i<1 || i>L->length)  //刪除位置不正確
		return ERROR;
	if (i <= L->length){
		*e = L->data[i - 1];
		for (k = i; k < L->length - 1;k++)
			L->data[i - 1] = L->data[i];
		L->length--;
		return OK;
	}

}
 

總結特點：查詢元素方便（時間複雜度O（1）），插入和刪除元素複雜（時間複雜度O（n））

typedef struct Node {         //定義連結串列中的節點
	int data; //假設資料為整型
	struct Node *next;
};
typedef struct Node  *Linklist;  //定義一個連結串列型別的指標

#define ERROR 0;
#define OK  1;
int GetElem(Linklist L, int i, int *e){
	int j=1;
	Linklist p;
	p = L->next;   //表示p指向了L->next，理解這點很重要
	while (p && j < 1){
		p = p->next;
		j++;
	}
	if (!p || j > i)
		return ERROR; 
	&e = p->data;
	return OK;
}

連結串列整表建立：頭插法

void CreatLinklist(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;
		(->next = p;       //插入到表頭
	}	
}

int LinklistInsert(LinkList L, int i, int e){
	int j;
	Linklist s, p;
	p = L;
	while (p && j < i){     //先找到插入的位置
		p = p->next;
		j++;
	}
	if (!p || j > i)
		return ERROR;
	s = (Linklist)malloc(sizeof(Node));
	s->data = e;
	s->next = p->next;     //插入連結串列ｓ到ｐ的後繼
	p->next = s;
	return OK;
}

連結串列的刪除：刪除第i個元素，返回其值到e中

int LinklistDelete(Linklist L, inti, int *e){
	int j = 1;
	Linklist p, q;
	p = L;
	while (p && j < i){
		p = p->next;
		j++;
	}
	if (!(p->next) || j > i)
		return ERROR;
	q = p->next;
	p->next = q->next;     //將q的後繼賦值給p
	*e = q->data;
	free(q);              //系統回收此節點，釋放記憶體
	return OK;
}

int CleatLinklist(Linklist L){
	Linklist p, q;
	p = L->next;
	while (p){
		q = p->next;
		free(q);
		p=q
	}
	L->next = NULL;    //頭結點指標域為空
	return OK;
}

3、迴圈連結串列

把單鏈表的終端節點指標域指向頭結點，就形成了迴圈連結串列，可方便進行連結串列全部結點的遍歷。判斷的方法就是看p->next是否為頭結點來結束迴圈

4、雙向連結串列

和單向連結串列區別僅在於多了一個prior指標指向前面的結點，因此插入和刪除操作也就多了幾個關於prior的步驟

定義

typedef struct Node {         //定義連結串列中的節點
	int data; //假設資料為整型
	struct Node *next;
	struct Node *prior;
};

單鏈表翻轉

思路是每次翻轉連結串列，把原始連結串列的第一個元素後面的那個元素放到表頭

LinkList ReverseLinkedList(LinkList L)
{
    Node   *first = NULL;  //指向原始連結串列最開始的第一個資料
    Node   *behind = NULL; //每次新生成連結串列時，指向原始連結串列最開始的第一個資料的下一個資料
 
    if (L == NULL)
    {
        return NULL;
    }
    first = L->next;
    while (first->next != NULL)
    {
        behind = first->next;
        first->next = behind->next;
        behind->next = L->next;
        L->next = behind;
    }
    return L;
}