線性表

線性表：最基本、最簡單、也是最常用的一種數據結構

線性表的定義

• 有窮性：一個線性表中的元素個數是有限的
• 一致性：一個線性表中所有元素的性質相同。從實現的角度看，所有元素具有相同的數據類型
• 序列性：一個線性表中所有元素之間的相對位置是線性的，即存在唯一的開始元素和終端元素，除此之外，每個元素只有唯一的前驅元素和后繼元素。各元素在線性表中的位置只取決於它們的序號，所以在一個線性表中可以存在兩個值相同的元素

順序表

• 順序表的定義
  • 線性表的順序存儲結構，指的是用一段地址連續的存儲單元依次存儲線性表的數據元素
  • 順序表存儲數據時，會提前申請一整塊足夠大小的物理空間，然后將數據依次存儲起來，存儲時做到數據元素之間不留一絲縫隙
• 順序存儲方式
  • 一維數組實現順序存儲結構

#define MAXSIZE 20          //存儲空間的初始分配量
typedef int ElemType;       //ElemType類型根據實際情況而定，這里是int
typedef struct
{
    ElemType data[MAXSIZE]; //數組，存儲數據元素
　　 int length;             //線性表當前長度
}SpList;

• • 描述順序存儲結構需要三個屬性
  • 存儲空間的起始位置：數組data，它的存儲位置就是存儲空間的存儲位置
  • 線性表的最大存儲容量：數組長度MAXSIZE
  • 線性表的當前長度：length
• 數組長度與線性表長度的區別
  • 數組長度：存放線性表的存儲空間的長度，存儲分配后這個量一般是不變的
  • 線性表長度：線性表中數據元素的個數，隨着線性表插入和刪除操作的進行，這個量是變化的
  • 在任意時刻，線性表的長度應該小於等於數組的長度

順序存儲結構的插入與刪除

• 獲得元素操作

#define OK 1
#define ERROR 0
/* 初始條件：順序線性表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已存在,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;
}

• 線性表的順序存儲結構的優缺點
• 優點：
• 無須為表示表中元素之間的邏輯關系而增加額外的存儲空間
• 可以快速地存取表中任一位置的元素
• 缺點：
• 插入和刪除操作需要移動大量元素
• 當線性表長度變化較大時，難以確定存儲空間的容量
• 造成存儲空間的碎片

線性表的鏈式存儲結構--鏈表

鏈表概述

線性表的鏈式存儲結構的特點是用一組任意的存儲單元存儲線性表的數據元素，這組存儲單元可以是連續的，也可以是不連續的。這就意味着，這些元素可以存在內存未被占用的任意位置

在鏈式結構中，不但要存儲數據元素信息外，還要存儲它的后繼元素的存儲地址

存儲元素信息的域稱為數據域，

存儲直接后繼位置的域稱為指針域

指針域中存儲的信息稱作指針或鏈

這兩部分信息組成數據元素ai的存儲映像，稱為結點（Node）

n個結點（ai的存儲映像）鏈結成一個鏈表，即為線性表（a1,a2,.....an）的鏈式存儲結構

因為此鏈表的每個結點中只包含一個指針域，所以叫做單鏈表

鏈表中第一個結點的存儲位置叫做頭指針

線性鏈表的最后一個結點指針為"空"

有時，為了更方便對鏈表進行操作，會在單鏈表的第一個結點前附設一個結點，稱為頭結點。

頭指針與頭結點的異同

頭指針：

• 頭指針是指鏈表指向第一個結點的指針，若鏈表有頭結點，則是指向頭結點的指針
• 頭指針具有標志作用，所以常用頭指針冠以鏈表的名字
• 無論鏈表是否為空，頭指針均不為空。頭指針是鏈表的必要元素

頭結點：

• 頭結點是為了操作的統一和方便而設立的，放在第一元素的結點之前，其數據域一般無意義（也可存放鏈表的長度）
• 有了頭結點，對在第一元素結點前插入結點和刪除第一結點，其操作與其他結點的操作就統一了
• 頭結點不一定是鏈表必需要素

線性表鏈式存儲結構代碼描述

定義一個單鏈表

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
typedef struct Node *LinkList; /* 定義LinkList */

單鏈表的讀取

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

單鏈表的插入

核心代碼
s->next = p->next;  //將p的后繼結點賦值給S的后綴
p->next = s;        //將S賦值給p的后繼

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

單鏈表的刪除

核心代碼
q = p->next;
p->next = q->next;
/* 初始條件：鏈式線性表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;
}

對於插入或刪除數據越頻繁的操作，單鏈表的效率優勢就越明顯

單鏈表的整表創建

/*  隨機產生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;                       /* 表示當前鏈表結束 */
}

單鏈表的整表刪除

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

單鏈表結構與順序存儲結構的對比

存儲分配方式

• 順序存儲結構用一段連續存儲單元依次存儲線性表的數據元素
• 單鏈表采用鏈式存儲結構，用一組任意的存儲單元存放線性表的元素

時間性能

• 查找
  • 順序存儲結構O(1)
  • 單鏈表O(n)
• 插入和刪除
  • 順序存儲結構需要平均移動表長一半的元素，時間復雜度為O(n)
  • 單鏈表在找出位置的指針后，插入和刪除時間復雜度僅為O(1)

空間性能

• 順序存儲結構需要預分配存儲空間，容易浪費或溢出
• 單鏈表不需要分配存儲空間，元素個數不受限制

靜態鏈表

用數組描述的鏈表叫做靜態鏈表

/* 線性表的靜態鏈表存儲結構 */
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;
}

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

/*  將下標為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;
}

靜態鏈表的優缺點

• 優點：在插入和刪除操作時，只需要修改游標，不需要移動元素，從而改進了在順序存儲結構中插入和刪除操作需要移動大量元素的缺點
• 缺點：沒有解決連續存儲分配帶來的表長難以確定的問題，失去了順序存儲結構隨機存取的特性

循環鏈表

 將單鏈表中終端結點的指針端由空指針改為指向頭結點，就使整個單鏈表形成一個環。

雙向鏈表

雙向鏈表是在單鏈表的每個結點中，再設置一個指向其前驅結點的指針域

/* 線性表的雙向鏈表存儲結構*/
typedef struct DulNode
{
    ElemType data;
    struct DoLNode *prior;     //直接前驅指針
    struct DoLNode *next;     //直接后繼指針      
}DulNode,*DuLinkList;

對於某一節點p，它的后繼的前驅是它自己，它的前驅的后繼也是它自己

p->next->prior = p = p->prior->next

雙向鏈表的插入操作

s->prior = p;        //把p賦值給s的前驅，如圖中的1
s->next = p->next;   //把p->next賦值給s的后繼，如圖中2
p->next->prior = s;  //把s賦值給p->next的前驅，如圖中3
p->next = s;         //把s賦值給p的后繼，如圖中4

雙向鏈表的刪除操作

p->prior->next = p->next;  //把p->next賦值給p->prior的后繼
p->next->prior = p->prior; //把p->prior賦值給p->next的前驅
free(p);                   //釋放結點