目錄

1.靜態連結串列的概念

因為有些語言沒有指標，所以難以實現普通連結串列，靜態連結串列就是用來解決這一問題的有力工具，靜態連結串列使用陣列來實現連結串列。靜態連結串列用遊標來代替普通連結串列的指標域，並且用下標代替普通連結串列的結點地址。

下面是一個靜態連結串列的示意圖

結合上圖來分析

（1）靜態連結串列的每個結點包含三個要素：下標、資料、遊標。下標表示當前元素所處的位置，類似於連結串列的結點地址；遊標存放下一個有效結點的下標，類似於連結串列的指標域。例如下標為2的元素，存放的資料為B，遊標值為3，說明下一個結點就是C。

（2）有效結點：含有資料的結點。

（3）第一個結點和最後一個結點不存放資料。第一個結點（下標為0）存放備用連結串列的第一個結點的下標；最後一個結點相當於連結串列的頭結點，該結點的遊標存放第一個有效結點的下標，當連結串列為空的時候，遊標為0。其他結點的遊標都存放下一個結點的下標。

（4）最後一個有效結點的遊標為0，說明下一個結點為空。

2.靜態連結串列的儲存結構

使用結構體陣列型別的資料來儲存靜態連結串列：

typedef struct
{
    ElemType data;//資料
    int cur;      //遊標
}StaticLinkList[MAXSIZE];
//一維陣列型別的定義方法：定義了一個元素型別為結構體，含有MAXSIZE個元素的陣列型別StaticLinkList
 

3.靜態連結串列的基本操作

（1）初始化：清空靜態連結串列，建立一個空的靜態連結串列。

（2）插入結點：在指定位置插入新結點。

（3）刪除結點：刪除指定位置的結點，並且回收該節點的儲存空間以便下次再用。

（4）新建靜態連結串列：將一系列元素放入空表。

（5）獲取靜態連結串列的長度：得到靜態連結串列中有效元素的個數。

4.靜態連結串列的程式設計實現

在程式的設計思路上，靜態連結串列的新建、插入和刪除等操作跟普通連結串列差不多，只需要注意靜態連結串列的一些約定條件即可。

       4.1C語言實現靜態連結串列

（1）靜態連結串列的宣告 staticlinklist.h

#ifndef STATICLINKLIST_H
#define STATICLINKLIST_H

#define MAXSIZE 1000
typedef int ElemType;
typedef enum Bool
{
    FALSE,TRUE//列舉預設值從0開始，依次加1
}Bool;

typedef struct
{
    ElemType data;//資料
    int cur;      //遊標
}StaticLinkList[MAXSIZE];
//一維陣列型別的定義方法：定義了一個元素型別為結構體，含有MAXSIZE個元素的陣列型別StaticLinkList

Bool InitList(StaticLinkList L);//初始化靜態表（也可以用來清空靜態表）
int Malloc_SLL(StaticLinkList L);//申請新結點
Bool ListInsert(StaticLinkList L,int i,ElemType e);//指定位置插入新結點
Bool ListDelete(StaticLinkList L,int i,ElemType* e);//刪除指定位置的結點
void Free_SLL(StaticLinkList L,int k);//將已刪除的結點釋放，方便下次再用
int ListLength(StaticLinkList L);//獲取靜態表的結點數目
void display(StaticLinkList L);//顯示當前的順序表
Bool CreatList(StaticLinkList L, int n);//用隨機數新建一個靜態表，其結點個數為n

#endif // STATICLINKLIST_H

（2） 靜態連結串列的實現 staticlinklist.c

#include "staticlinklist.h"

Bool InitList(StaticLinkList L)
{
    int i;
    for(i=0;i<MAXSIZE-1;i++)
        L[i].cur=i+1;//第0個元素的遊標指向第1個有效元素的下標，有效資料是從1開始的（第一個元素不儲存資訊）

    L[MAXSIZE-1].cur=0;
    return TRUE;
}

/*獲取新節點
 *1.得到備用結點的下標
 *2.更新當前連結串列的第一個結點的遊標
 */
int Malloc_SLL(StaticLinkList L)
{
    int i=L[0].cur;//獲取備用結點的下標
    if(i)//備用連結串列不是空連結串列
        L[0].cur=L[i].cur;//更新備用連結串列頭結點
    return i;
}

//將備用連結串列的第一個結點作為待插入的新結點
//插入方法：
//1.將新結點的下標值放入待插入位置的前一個結點的遊標；
//2.新結點的遊標值為，插入正確位置後，下一個結點的下標值。
Bool ListInsert(StaticLinkList L,int i,ElemType e)
{
    int j,k,l;

    k=MAXSIZE-1;//最後一個結點存放當前連結串列的起始下標
    if(i<1||i>ListLength(L)+1)//插入位置不合理
        return FALSE;

    j=Malloc_SLL(L);//新結點下標 
    if(j)//新節點不為空
    {
        L[j].data=e;
        for(l=0;l<i-1;l++)//這個下標值對應的結點的遊標存放待插入位置的下標（包括第一個位置）
            k=L[k].cur;

        L[j].cur=L[k].cur;//新結點的遊標存放原來處於第i個位置的結點下標值（即當前結點的遊標）
        L[k].cur=j;//更新當前結點的遊標值
        return TRUE;
    }
    return FALSE;
}

Bool ListDelete(StaticLinkList L,int i,ElemType* e)
{
    int j,k;

    k=MAXSIZE-1;//待刪除的前一個結點下標
    if(i<1||i>ListLength(L))//刪除位置不合理
        return FALSE;

    for(j=0;j<i-1;j++)//尋找刪除點的下標值
        k=L[k].cur;

    j=L[k].cur;//待刪除結點的下標
    L[k].cur=L[j].cur;//待刪除結點的遊標值（下個結點的位置）賦給待刪除結點前一個結點的遊標
    *e=L[j].data;
    Free_SLL(L,j);
    return TRUE;
}

void Free_SLL(StaticLinkList L,int k)
{
    L[k].cur=L[0].cur;//待刪除結點作為新的備用連結串列頭結點，他的遊標為原來的頭結點下標
    L[0].cur=k;//更新備用連結串列頭結點的下標值
}

int ListLength(StaticLinkList L)
{
    int i=0,j;
    j=L[MAXSIZE-1].cur;//頭結點的下標值
    while (j)
    {
        i++;
        j=L[j].cur;
    }
    return i;
}

void display(StaticLinkList L)
{
    int j;
    j=L[MAXSIZE-1].cur;//頭結點的下標值
    if(j==0)
        printf("這是一個空的靜態表");
    while (j)
    {
        printf("%d  ",L[j].data);
        j=L[j].cur;
    }
    printf("\n\n");
}

Bool CreatList(StaticLinkList L, int n)//新建一個靜態表
{
    int i,j;

    if(n<1||n>MAXSIZE-2)//結點數目不合理
        return FALSE;

    if(L[MAXSIZE-1].cur)//當前靜態表非空
        return FALSE;

    j=L[0].cur;//起始結點的下標
    for(i=1;i<n;i++)
    {
        L[j].data=rand()%100;
//        printf("新建元素%d  ",L[j].data);
        j=L[j].cur;
    }

    L[j].data=rand()%100+1;//最後一個元素
    L[j].cur=0;//最後一個元素的遊標為0

    L[MAXSIZE-1].cur=L[0].cur;//最後一個結點存放當前連結串列的起始下標
    L[0].cur=j;//最後一個元素的下標
//    printf("新建元素%d  \n",L[i].data);
    return TRUE;
}

（3）測試程式 main.c

#include <stdio.h>
#include "staticlinklist.h"

int main()
{
    StaticLinkList List;
    int i;
    ElemType e;

    printf("            1.初始化靜態連結串列\n");
    InitList(List);
    display(List);

    printf("\n            2.插入5個結點\n");
    for(i=0;i<5;i++)
    {
        printf("插入第%d個結點:%d\n",i+1,i);
        ListInsert(List,i+1,i);
        display(List);
    }

    printf("\n            3.刪除5個結點\n");
    for(i=0;i<5;i++)
    {
        ListDelete(List,1,&e);
        printf("刪除第%d個結點:%d\n",i+1,e);
        display(List);
    }


//    InitList(List);新建連結串列的時候不要求連結串列必須初始化，只要是空靜態表就能新建
    printf("\n            4.隨機建立10個結點\n");
    CreatList(List,10);
    display(List);

    printf("\n            5.清空靜態表\n");
    InitList(List);
    display(List);

    return 0;
}

       4.2C++實現靜態連結串列

（1）靜態連結串列的宣告  staticlinklist.h

#ifndef STATICLINKLIST_H
#define STATICLINKLIST_H

#define MAXSIZE 1000

template<typename ElemType>//用類模板來代替typedef int ElemType;
class staticLinkList
{
public:
    staticLinkList();//初始化靜態表
    typedef struct
    {
        ElemType data;//資料
        int cur;      //遊標
    }Node;

    int Malloc_SLL();//申請新結點
    bool ListInsert(int i,ElemType e);//指定位置插入新結點
    bool ListDelete(int i,ElemType* e);//刪除指定位置的結點
    void Free_SLL(int k);//將已刪除的結點釋放，方便下次再用
    int ListLength();//獲取靜態表的結點數目
    void display();//顯示當前的順序表
    bool CreatList(ElemType a[],int n);//用隨機數新建一個靜態表，其結點個數為n
    void ListDelete();
private:
    Node L[MAXSIZE];

};

#endif // STATICLINKLIST_H

（2）靜態連結串列的實現  staticlinklist.cpp

#include <iostream>
#include "staticlinklist.h"
using namespace std;

template<typename ElemType>
staticLinkList<ElemType>::staticLinkList()
{
    int i;
    for(i=0;i<MAXSIZE-1;i++)
        L[i].cur=i+1;//第0個元素的遊標指向第1個有效元素的下標，有效資料是從1開始的（第一個元素不儲存資訊）
    L[MAXSIZE-1].cur=0;
}

template<typename ElemType>
int  staticLinkList<ElemType>::Malloc_SLL()
{
    int i=L[0].cur;//獲取備用結點的下標
    if(i)//備用連結串列不是空連結串列
        L[0].cur=L[i].cur;//更新備用連結串列頭結點
    return i;
}

template<typename ElemType>
bool staticLinkList<ElemType>::ListInsert(int i,ElemType e)
{
    int j,k,l;

    k=MAXSIZE-1;//最後一個結點存放當前連結串列的起始下標
    if(i<1||i>ListLength()+1)//插入位置不合理
        return  false;

    j=Malloc_SLL();//新結點下標
    if(j)//新節點不為空
    {
        L[j].data=e;
        for(l=0;l<i-1;l++)//這個下標值對應的結點的遊標存放待插入位置的下標（包括第一個位置）
            k=L[k].cur;

        L[j].cur=L[k].cur;//新結點的遊標存放原來處於第i個位置的結點下標值（即當前結點的遊標）
        L[k].cur=j;//更新當前結點的遊標值
        return  true;
    }
    return  false;
}

template<typename ElemType>
bool staticLinkList<ElemType>::ListDelete(int i,ElemType* e)
{
    int j,k;

    k=MAXSIZE-1;//待刪除的前一個結點下標
    if(i<1||i>ListLength())//刪除位置不合理
        return  false;

    for(j=0;j<i-1;j++)//尋找刪除點的下標值
        k=L[k].cur;

    j=L[k].cur;//待刪除結點的下標
    L[k].cur=L[j].cur;//待刪除結點的遊標值（下個結點的位置）賦給待刪除結點前一個結點的遊標
    *e=L[j].data;
    Free_SLL(j);
    return  true;
}

template<typename ElemType>
void staticLinkList<ElemType>::Free_SLL(int k)
{
    L[k].cur=L[0].cur;//待刪除結點作為新的備用連結串列頭結點，他的遊標為原來的頭結點下標
    L[0].cur=k;//更新備用連結串列頭結點的下標值
}

template<typename ElemType>
int  staticLinkList<ElemType>::ListLength()
{
    int i=0,j;
    j=L[MAXSIZE-1].cur;//頭結點的下標值
    while (j)
    {
        i++;
        j=L[j].cur;
    }
    return i;
}

template<typename ElemType>
void staticLinkList<ElemType>::display()
{
    int j;
    j=L[MAXSIZE-1].cur;//頭結點的下標值
    if(j==0)
        printf("這是一個空的靜態表");
    while (j)
    {
        cout<<L[j].data<<"  ";
        j=L[j].cur;
    }
    cout<<endl<<endl;
}

template<typename ElemType>
bool staticLinkList<ElemType>::CreatList(ElemType a[],int n)
{
    int i,j;

    if(n<1||n>MAXSIZE-2)//結點數目不合理
        return  false;

    if(L[MAXSIZE-1].cur)//當前靜態表非空
        return  false;

    j=L[0].cur;//起始結點的下標
    for(i=0;i<n-1;i++)
    {
        L[j].data=a[i];
        j=L[j].cur;
    }

    L[j].data=a[i];//最後一個元素
    L[j].cur=0;//最後一個元素的遊標為0

    L[MAXSIZE-1].cur=L[0].cur;//最後一個結點存放當前連結串列的起始下標
    L[0].cur=j;//最後一個元素的下標
    return  true;
}

template<typename ElemType>
void staticLinkList<ElemType>::ListDelete()
{
    int i;
    for(i=0;i<MAXSIZE-1;i++)
        L[i].cur=i+1;//第0個元素的遊標指向第1個有效元素的下標，有效資料是從1開始的（第一個元素不儲存資訊）
    L[MAXSIZE-1].cur=0;
}

（3）測試程式  main.cpp

#include <iostream>
#include "staticlinklist.cpp"//類模板要求在編譯的時候能同時訪問模板定義和方法定義
using namespace std;

int main()
{
    staticLinkList<int> List;//模板類
    int i,e;

    cout<<"            1.初始化靜態連結串列\n"<<endl;
    List.display();

    cout<<"\n            2.插入5個結點\n"<<endl;
    for(i=0;i<5;i++)
    {
        cout<<"插入第"<<i+1<<"個結點:"<<i<<endl;
        List.ListInsert(i+1,i);
        List.display();
    }

    cout<<"\n            3.刪除5個結點\n"<<endl;
    for(i=0;i<5;i++)
    {
        List.ListDelete(1,&e);
        cout<<"刪除第"<<i+1<<"個結點:"<<e<<endl;
        List.display();
    }

    cout<<"\n            4.新建靜態表\n"<<endl;
    int a[10];
    for(i=0;i<10;i++)
        a[i]=rand()%100;
    List.CreatList(a,10);
    List.display();

    cout<<"\n            5.清空靜態表\n"<<endl;
    List.ListDelete();
    List.display();

    return 0;
}

       4.3測試結果

5.靜態連結串列的特點

優點：

與單鏈表類似，插入和刪除的時候不需要移動大量元素；

缺點：

1.沒有解決連續儲存分配（陣列）帶來的表長難以確定的問題；

2.失去了順序儲存結構隨機存取的特性。

6.參考資料