【C語言描述】《數據結構和算法》

說是這個教程是按照《大話數據結構》這本書來編寫的：數據結構與算法經典書籍——大話數據結構（帶配套源碼）

↑廢話太TM多了，換一個！

【搞定數據結構和算法】數據結構和算法考研教程數據結構考研嚴蔚敏

這個好像可以，看這個。。。

但是沒更完啊！換一個！

我裂開了，還是回去看那個小甲魚的羅里吧嗦的教程吧！

越聽越暈，wo TM還是不看視頻了，直接看書吧，《大話數據結構》！

文章目錄

• • 第一章：數據結構緒論
  • • 邏輯結構與物理結構（存儲結構）
    • 順序存儲結構與鏈式存儲結構
    • 原子類型數據與結構類型數據（39）
    • 抽象數據類型（40）
  • 第二章：算法
  • • 事前分析估算方法（53）
    • 分析算法運行時間：將基本操作數量表示成輸入規模的函數（54）
    • 判斷一個算法效率時，函數中的常數和其他次要項常常可以忽略，而更應該關注主項（最高階項）（57）
    • 算法時間復雜度 T(n) = O(f(n))（57）
    • 大O記法 常數階 線性階 平方階（58）
    • 推導大O階方法（58）
    • 對數階（60）
    • 常見時間復雜度及排名（63）
    • 運行時間通常指最壞的情況的運行時間（64）
    • 平均運行時間：最有意義的運行時間（需要用上概率計算方法）（64）
    • 算法空間復雜度：用空間換時間的方法（65）
    • 算法的空間復雜度通過計算算法所需的存儲空間實現，算法空間復雜度的計算公式記作：S(n) = O(f(n))，其中，n為問題的規模，f(n)為語句關于n所占存儲空間的函數。（65）
    • 空間復雜度：算法原地工作O(1) （65）
    • 復雜度通常指時間復雜度（65）
    • 大O階的推導方法（66）
    • 常見時間復雜度所耗時間排列順序（66）
  • 第三章：線性表
  • • 線性表：零個或多個數據元素的有限序列（71）
    • 前驅元素與后繼元素（71）
    • 線性表的長度n，當n = 0，這個線性表稱為空表（71）
    • 線性表的抽象數據類型（73）
    • 線性表的順序存儲結構（75）
    • 數組長度與線性表長度的區別：數組長度是存放線性表的存儲空間的長度，線性表長度是線性表中數據元素的個數（77）
    • 隨機存儲結構的概念（有啥用？）（78）
    • 順序存儲結構的插入與刪除（固定表，沒啥優勢吧！為什么講這個？）（78）
    • 線性表順序存儲結構的優缺點（82）
    • 線性表的鏈式存儲結構（83）
    • 數據域與指針域，結點（node）的概念（85）
    • 頭指針：鏈表第一個結點的存儲位置，如果有頭結點，則指向頭結點，頭結點不是必須的（85）
    • 頭結點：可存線性表長度等公共數據（86）
    • 單鏈表的讀取（88）
    • 單鏈表的插入與刪除（89）
    • 單鏈表的優勢：插入或刪除數據的頻繁操作（94）
    • 單鏈表整表的創建（94）
    • 頭插法與尾插法（95）
    • 單鏈表整表的刪除（97）
    • 單鏈表結構與順序存儲結構優缺點（98）
    • 靜態鏈表：用數組描述的鏈表（游標實現法）（這個貌似只適合在不能用指針的語言中使用，如java、c#）（99）
    • 靜態鏈表優缺點（可能靜態鏈表平時都不怎么用得到！）（105）
    • 單向循環鏈表（106）
    • 尾指針（rear）(108)
    • 循環鏈表的合并（108）
    • 雙向循環鏈表（109）
    • 01線性表順序存儲_List（代碼示例）
    • 02線性表鏈式存儲_LinkList（代碼示例）
    • 03靜態鏈表_StaticLinkList（代碼示例）

第一章：數據結構緒論

邏輯結構與物理結構（存儲結構）

順序存儲結構與鏈式存儲結構

原子類型數據與結構類型數據（39）

抽象數據類型（40）

第二章：算法

事前分析估算方法（53）

分析算法運行時間：將基本操作數量表示成輸入規模的函數（54）

判斷一個算法效率時，函數中的常數和其他次要項常常可以忽略，而更應該關注主項（最高階項）（57）

算法時間復雜度 T(n) = O(f(n))（57）

大O記法 常數階 線性階 平方階（58）

推導大O階方法（58）

對數階（60）

常見時間復雜度及排名（63）

運行時間通常指最壞的情況的運行時間（64）

平均運行時間：最有意義的運行時間（需要用上概率計算方法）（64）

算法空間復雜度：用空間換時間的方法（65）

算法的空間復雜度通過計算算法所需的存儲空間實現，算法空間復雜度的計算公式記作：S(n) = O(f(n))，其中，n為問題的規模，f(n)為語句關于n所占存儲空間的函數。（65）

空間復雜度：算法原地工作O(1) （65）

復雜度通常指時間復雜度（65）

大O階的推導方法（66）

常見時間復雜度所耗時間排列順序（66）

第三章：線性表

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

前驅元素與后繼元素（71）

線性表的長度n，當n = 0，這個線性表稱為空表（71）

線性表的抽象數據類型（73）

線性表的順序存儲結構（75）

數組長度與線性表長度的區別：數組長度是存放線性表的存儲空間的長度，線性表長度是線性表中數據元素的個數（77）

隨機存儲結構的概念（有啥用？）（78）

順序存儲結構的插入與刪除（固定表，沒啥優勢吧！為什么講這個？）（78）

線性表順序存儲結構的優缺點（82）

線性表的鏈式存儲結構（83）

數據域與指針域，結點（node）的概念（85）

頭指針：鏈表第一個結點的存儲位置，如果有頭結點，則指向頭結點，頭結點不是必須的（85）

頭結點：可存線性表長度等公共數據（86）

單鏈表的讀取（88）

單鏈表的插入與刪除（89）

單鏈表的優勢：插入或刪除數據的頻繁操作（94）

單鏈表整表的創建（94）

頭插法與尾插法（95）

單鏈表整表的刪除（97）

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

下面不太理解，如果用用戶名去查找，順序存儲結構與鏈表不都需要從頭查到尾一個一個去匹配嗎？

靜態鏈表：用數組描述的鏈表（游標實現法）（這個貌似只適合在不能用指針的語言中使用，如java、c#）（99）

（通俗易懂）（102）

靜態鏈表優缺點（可能靜態鏈表平時都不怎么用得到！）（105）

單向循環鏈表（106）

或（用尾指針代替頭指針的單向循環鏈表）

尾指針（rear）(108)

循環鏈表的合并（108）

雙向循環鏈表（109）

01線性表順序存儲_List（代碼示例）

#include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h"constexpr auto OK = 1; constexpr auto ERROR = 0; constexpr auto TRUE = 1; constexpr auto FALSE = 0; constexpr auto MAXSIZE = 20 /* 存儲空間初始分配量 */;typedef int Status; /* Status是函數的類型,其值是函數結果狀態代碼，如OK等 */ typedef int ElemType; /* ElemType類型根據實際情況而定，這里假設為int */Status visit(ElemType c) {printf("%d ", c);return OK; }typedef struct {ElemType data[MAXSIZE]; /* 數組，存儲數據元素 */int length; /* 線性表當前長度 */ }SqList;/* 初始化順序線性表 */ Status InitList(SqList* L) {L->length = 0;return OK; }/* 初始條件：順序線性表L已存在。操作結果：若L為空表，則返回TRUE，否則返回FALSE */ Status ListEmpty(SqList L) {if (L.length == 0)return TRUE;elsereturn FALSE; }/* 初始條件：順序線性表L已存在。操作結果：將L重置為空表 */ Status ClearList(SqList* L) {L->length = 0;return OK; }/* 初始條件：順序線性表L已存在。操作結果：返回L中數據元素個數 */ int ListLength(SqList L) {return L.length; }/* 初始條件：順序線性表L已存在，1≤i≤ListLength(L) */ /* 操作結果：用e返回L中第i個數據元素的值,注意i是指位置，第1個位置的數組是從0開始 */ 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; }/* 初始條件：順序線性表L已存在 */ /* 操作結果：返回L中第1個與e滿足關系的數據元素的位序。 */ /* 若這樣的數據元素不存在，則返回值為0 */ int LocateElem(SqList L, ElemType e) {int i;if (L.length == 0)return 0;for (i = 0; i < L.length; i++){if (L.data[i] == e)break;}if (i >= L.length)return 0;return i + 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--) /* 將要插入位置之后的數據元素向后移動一位 */L->data[k + 1] = L->data[k];}L->data[i - 1] = e; /* 將新元素插入 */L->length++;return OK; }/* 初始條件：順序線性表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];if (i < L->length) /* 如果刪除不是最后位置 */{for (k = i; k < L->length; k++)/* 將刪除位置后繼元素前移 */L->data[k - 1] = L->data[k];}L->length--;return OK; }/* 初始條件：順序線性表L已存在 */ /* 操作結果：依次對L的每個數據元素輸出 */ Status ListTraverse(SqList L) {int i;for (i = 0; i < L.length; i++)visit(L.data[i]);printf("\n");return OK; }void unionL(SqList* La, SqList Lb) {int La_len, Lb_len, i;ElemType e;La_len = ListLength(*La);Lb_len = ListLength(Lb);for (i = 1; i <= Lb_len; i++){GetElem(Lb, i, &e);if (!LocateElem(*La, e))ListInsert(La, ++La_len, e);} }int main() {SqList L;SqList Lb;ElemType e;Status i;int j, k;i = InitList(&L);printf("初始化L后：L.length=%d\n", L.length);for (j = 1; j <= 5; j++)i = ListInsert(&L, 1, j);printf("在L的表頭依次插入1～5后：L.data=");ListTraverse(L);printf("L.length=%d \n", L.length);i = ListEmpty(L);printf("L是否空：i=%d(1:是 0:否)\n", i);i = ClearList(&L);printf("清空L后：L.length=%d\n", L.length);i = ListEmpty(L);printf("L是否空：i=%d(1:是 0:否)\n", i);for (j = 1; j <= 10; j++)ListInsert(&L, j, j);printf("在L的表尾依次插入1～10后：L.data=");ListTraverse(L);printf("L.length=%d \n", L.length);ListInsert(&L, 1, 0);printf("在L的表頭插入0后：L.data=");ListTraverse(L);printf("L.length=%d \n", L.length);GetElem(L, 5, &e);printf("第5個元素的值為：%d\n", e);for (j = 3; j <= 4; j++){k = LocateElem(L, j);if (k)printf("第%d個元素的值為%d\n", k, j);elseprintf("沒有值為%d的元素\n", j);}k = ListLength(L); /* k為表長 */for (j = k + 1; j >= k; j--){i = ListDelete(&L, j, &e); /* 刪除第j個數據 */if (i == ERROR)printf("刪除第%d個數據失敗\n", j);elseprintf("刪除第%d個的元素值為：%d\n", j, e);}printf("依次輸出L的元素：");ListTraverse(L);j = 5;ListDelete(&L, j, &e); /* 刪除第5個數據 */printf("刪除第%d個的元素值為：%d\n", j, e);printf("依次輸出L的元素：");ListTraverse(L);//構造一個有10個數的Lbi = InitList(&Lb);for (j = 6; j <= 15; j++)i = ListInsert(&Lb, 1, j);unionL(&L, Lb);printf("依次輸出合并了Lb的L的元素：");ListTraverse(L);return 0; }

運行結果：

初始化L后：L.length=0 在L的表頭依次插入1～5后：L.data=5 4 3 2 1 L.length=5 L是否空：i=0(1:是 0:否) 清空L后：L.length=0 L是否空：i=1(1:是 0:否) 在L的表尾依次插入1～10后：L.data=1 2 3 4 5 6 7 8 9 10 L.length=10 在L的表頭插入0后：L.data=0 1 2 3 4 5 6 7 8 9 10 L.length=11 第5個元素的值為：4 第4個元素的值為3 第5個元素的值為4 刪除第12個數據失敗 刪除第11個的元素值為：10 依次輸出L的元素：0 1 2 3 4 5 6 7 8 9 刪除第5個的元素值為：4 依次輸出L的元素：0 1 2 3 5 6 7 8 9 依次輸出合并了Lb的L的元素：0 1 2 3 5 6 7 8 9 15 14 13 12 11 10

02線性表鏈式存儲_LinkList（代碼示例）

#include "stdio.h" #include "string.h" #include "ctype.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h"#define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0#define MAXSIZE 20 /* 存儲空間初始分配量 */typedef int Status;/* Status是函數的類型,其值是函數結果狀態代碼，如OK等 */ typedef int ElemType;/* ElemType類型根據實際情況而定，這里假設為int */Status visit(ElemType c) {printf("%d ", c);return OK; }typedef struct Node {ElemType data;struct Node* next; }Node;typedef struct Node* LinkList; /* 定義LinkList *//* 初始化順序線性表 */ Status InitList(LinkList* L) {*L = (LinkList)malloc(sizeof(Node)); /* 產生頭結點,并使L指向此頭結點 */if (!(*L)) /* 存儲分配失敗 */return ERROR;(*L)->next = NULL; /* 指針域為空 */return OK; }/* 初始條件：順序線性表L已存在。操作結果：若L為空表，則返回TRUE，否則返回FALSE */ Status ListEmpty(LinkList L) {if (L->next)return FALSE;elsereturn TRUE; }/* 初始條件：順序線性表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; }/* 初始條件：順序線性表L已存在。操作結果：返回L中數據元素個數 */ int ListLength(LinkList L) {int i = 0;LinkList p = L->next; /* p指向第一個結點 */while (p){i++;p = p->next;}return i; }/* 初始條件：順序線性表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; }/* 初始條件：順序線性表L已存在 */ /* 操作結果：返回L中第1個與e滿足關系的數據元素的位序。 */ /* 若這樣的數據元素不存在，則返回值為0 */ int LocateElem(LinkList L, ElemType e) {int i = 0;LinkList p = L->next;while (p){i++;if (p->data == e) /* 找到這樣的數據元素 */return i;p = p->next;}return 0; }/* 初始條件：順序線性表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;j = 1;while (p && j < i) /* 尋找第i個結點 */{p = p->next;++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; }/* 初始條件：順序線性表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; }/* 初始條件：順序線性表L已存在 */ /* 操作結果：依次對L的每個數據元素輸出 */ Status ListTraverse(LinkList L) {LinkList p = L->next;while (p){visit(p->data);p = p->next;}printf("\n");return OK; }/* 隨機產生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)); /* 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; /* 表示當前鏈表結束 */ }int main() {LinkList L;ElemType e;Status i;int j, k;i = InitList(&L);printf("初始化L后：ListLength(L)=%d\n", ListLength(L));for (j = 1; j <= 5; j++)i = ListInsert(&L, 1, j);printf("在L的表頭依次插入1～5后：L.data=");ListTraverse(L);printf("ListLength(L)=%d \n", ListLength(L));i = ListEmpty(L);printf("L是否空：i=%d(1:是 0:否)\n", i);i = ClearList(&L);printf("清空L后：ListLength(L)=%d\n", ListLength(L));i = ListEmpty(L);printf("L是否空：i=%d(1:是 0:否)\n", i);for (j = 1; j <= 10; j++)ListInsert(&L, j, j);printf("在L的表尾依次插入1～10后：L.data=");ListTraverse(L);printf("ListLength(L)=%d \n", ListLength(L));ListInsert(&L, 1, 0);printf("在L的表頭插入0后：L.data=");ListTraverse(L);printf("ListLength(L)=%d \n", ListLength(L));GetElem(L, 5, &e);printf("第5個元素的值為：%d\n", e);for (j = 3; j <= 4; j++){k = LocateElem(L, j);if (k)printf("第%d個元素的值為%d\n", k, j);elseprintf("沒有值為%d的元素\n", j);}k = ListLength(L); /* k為表長 */for (j = k + 1; j >= k; j--){i = ListDelete(&L, j, &e); /* 刪除第j個數據 */if (i == ERROR)printf("刪除第%d個數據失敗\n", j);elseprintf("刪除第%d個的元素值為：%d\n", j, e);}printf("依次輸出L的元素：");ListTraverse(L);j = 5;ListDelete(&L, j, &e); /* 刪除第5個數據 */printf("刪除第%d個的元素值為：%d\n", j, e);printf("依次輸出L的元素：");ListTraverse(L);i = ClearList(&L);printf("\n清空L后：ListLength(L)=%d\n", ListLength(L));CreateListHead(&L, 20);printf("整體創建L的元素(頭插法)：");ListTraverse(L);i = ClearList(&L);printf("\n刪除L后：ListLength(L)=%d\n", ListLength(L));CreateListTail(&L, 20);printf("整體創建L的元素(尾插法)：");ListTraverse(L);return 0; }

運行結果：

初始化L后：ListLength(L)=0 在L的表頭依次插入1～5后：L.data=5 4 3 2 1 ListLength(L)=5 L是否空：i=0(1:是 0:否) 清空L后：ListLength(L)=0 L是否空：i=1(1:是 0:否) 在L的表尾依次插入1～10后：L.data=1 2 3 4 5 6 7 8 9 10 ListLength(L)=10 在L的表頭插入0后：L.data=0 1 2 3 4 5 6 7 8 9 10 ListLength(L)=11 第5個元素的值為：4 第4個元素的值為3 第5個元素的值為4 刪除第12個數據失敗 刪除第11個的元素值為：10 依次輸出L的元素：0 1 2 3 4 5 6 7 8 9 刪除第5個的元素值為：4 依次輸出L的元素：0 1 2 3 5 6 7 8 9清空L后：ListLength(L)=0 整體創建L的元素(頭插法)：95 12 16 84 1 20 90 85 31 24 27 28 29 65 51 53 28 40 24 89刪除L后：ListLength(L)=0 整體創建L的元素(尾插法)：89 24 40 28 53 51 65 29 28 27 24 31 85 90 20 1 84 16 12 95

03靜態鏈表_StaticLinkList（代碼示例）

#include "string.h" #include "ctype.h" #include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h"#define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0#define MAXSIZE 1000 /* 存儲空間初始分配量 */typedef int Status; /* Status是函數的類型,其值是函數結果狀態代碼，如OK等 */ typedef char ElemType; /* ElemType類型根據實際情況而定，這里假設為char */Status visit(ElemType c) {printf("%c ", c);return OK; }/* 線性表的靜態鏈表存儲結構 */ typedef struct {ElemType data;int cur; /* 游標(Cursor) ，為0時表示無指向 */ } Component, StaticLinkList[MAXSIZE];/* 將一維數組space中各分量鏈成一個備用鏈表，space[0].cur為頭指針，"0"表示空指針 */ Status InitList(StaticLinkList space) {int i;for (i = 0; i < MAXSIZE - 1; i++)space[i].cur = i + 1;space[MAXSIZE - 1].cur = 0; /* 目前靜態鏈表為空，最后一個元素的cur為0 */return OK; }/* 若備用空間鏈表非空，則返回分配的結點下標，否則返回0 */ int Malloc_SSL(StaticLinkList space) {int i = space[0].cur; /* 當前數組第一個元素的cur存的值 *//* 就是要返回的第一個備用空閑的下標 */if (space[0].cur)space[0].cur = space[i].cur; /* 由于要拿出一個分量來使用了， *//* 所以我們就得把它的下一個 *//* 分量用來做備用 */return i; }/* 將下標為k的空閑結點回收到備用鏈表 */ void Free_SSL(StaticLinkList space, int k) {space[k].cur = space[0].cur; /* 把第一個元素的cur值賦給要刪除的分量cur */space[0].cur = k; /* 把要刪除的分量下標賦值給第一個元素的cur */ }/* 初始條件：靜態鏈表L已存在。操作結果：返回L中數據元素個數 */ int ListLength(StaticLinkList L) {int j = 0;int i = L[MAXSIZE - 1].cur;while (i){i = L[i].cur;j++;}return j; }/* 在L中第i個元素之前插入新的數據元素e */ Status ListInsert(StaticLinkList L, int i, ElemType e) {int j, k, l;k = MAXSIZE - 1; /* 注意k首先是最后一個元素的下標 */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 */L[k].cur = j; /* 把新元素的下標賦值給第i個元素之前元素的ur */return OK;}return ERROR; }/* 刪除在L中第i個數據元素 */ 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; }Status ListTraverse(StaticLinkList L) {int j = 0;int i = L[MAXSIZE - 1].cur;while (i){visit(L[i].data);i = L[i].cur;j++;}return j;printf("\n");return OK; }int main() {StaticLinkList L;Status i;i = InitList(L);printf("初始化L后：L.length=%d\n", ListLength(L));i = ListInsert(L, 1, 'F');i = ListInsert(L, 1, 'E');i = ListInsert(L, 1, 'D');i = ListInsert(L, 1, 'B');i = ListInsert(L, 1, 'A');printf("\n在L的表頭依次插入FEDBA后：\nL.data=");ListTraverse(L);i = ListInsert(L, 3, 'C');printf("\n在L的“B”與“D”之間插入“C”后：\nL.data=");ListTraverse(L);i = ListDelete(L, 1);printf("\n在L的刪除“A”后：\nL.data=");ListTraverse(L);printf("\n");return 0; }

運行結果：

初始化L后：L.length=0在L的表頭依次插入FEDBA后： L.data=A B D E F 在L的“B”與“D”之間插入“C”后： L.data=A B C D E F 在L的刪除“A”后： L.data=B C D E F

總結

以上是生活随笔為你收集整理的C语言数据结构（大话数据结构——笔记1）数据结构绪论、算法、线性表的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。