1.線性表的特點：（在資料元素的非空集合中）

　　存在唯一的“第一個”資料元素(只適用大部分線性表，迴圈連結串列就不符合)

　　存在唯一的“最後一個”資料元素(只適用大部分線性表，迴圈連結串列就不符合)

　　除第一個元素外，每個元素只存在一個前驅

　　除最後一個元素外，每個元素只存在一個後繼

1.2順序表：

特點：

　　特點：用一組地址連續的儲存單元依次儲存線性表的元素；只要確定其起始地址，任一元素都可隨機存取

　　缺點：插入或刪除一個元素，會移動大量元素，以下程式碼來自https://blog.csdn.net/weixin_42274148/article/details/83189347?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-11.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-11.nonecase

//01線性表順序儲存_List
#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 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;
    else
        return 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);
            else
                    printf("沒有值為%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);
            else
                    printf("刪除第%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個數的Lb
    i=InitList(&Lb);
    for(j=6;j<=15;j++)
            i=ListInsert(&Lb,1,j);
 
    unionL(&L,Lb);
 
    printf("依次輸出合併了Lb的L的元素：");
    ListTraverse(L); 
 
    return 0;
}
 

1.3線性連結串列：

　　特點：用一組任意的儲存單元儲存線性表的元素；所以，除了儲存元素本身資訊外(資料域)，還需儲存一個指示其後繼的資訊(指標域)，這兩部分組成一個節點

　　存取：必須從頭指標(指示連結串列中的第一個節點的儲存位置)開始；由於最後一個元素沒有後繼，其指標域為NULL，L即為頭指標

　　頭節點：有時會在第一個節點前附設一個節點，其資料域可以為空，也可儲存線性表長度等類的附加資訊，其指標域為第一個元素節點的儲存地址(此時頭指標就指向了頭節點)

//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;
    else
            return 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);
            else
                    printf("沒有值為%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);
            else
                    printf("刪除第%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;
}
 

1.4靜態連結串列：

　　特點：使用一維陣列來表示，此法適用於沒有指標型別的語言中使用連結串列，陣列的一個分量表示一個節點，用遊標代替指標指示示在連結串列中的位置，陣列第一個元素可以看成頭節點，其指標域(現為遊標)指向第一個節點

　　插入刪除：不需移動元素，修改遊標即可，仍具連結串列的主要優點

//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;
}