C語言實現--靜態鏈表的操作

1，我們研究數據結構的操作，第一要弄懂它的結構體表示（也就是結構體特點）、第二要清楚它的初始化和撤銷過程。對於靜態鏈表首先分析它的特點：一是采用靜態存儲方式，二是沒有指針。靜態鏈表就是不用指針來表示鏈式關系的一種巧妙實現。

2，靜態鏈表的結構體定義

#define MAX 100

typedef struct
{
    int data;   //數據域的類型可以是任意的基類型，包括數組
    int cur;
}component, slinklist[MAX]

3，靜態鏈表的初始化示意圖

4，靜態鏈表的操作集合，與單鏈表一致，均在頭文件defs.h中。此頭文件在前面文章中已經寫出。

5，初始化操作的實現

#include"defs.h"

void InitList(slinklist s)
{
    int i;
    L[MAX-1].cur = 0;   //令鏈表頭結點為空
   
   for (i=0; i<MAX-2; i++) //其余元素構成備用鏈表
        L[i].cur = i+1; 
    L[MAX-2].cur = 0;   //備用鏈表最后一個元素置為空
}

6，靜態鏈表撤銷操作的實現，原理就是將鏈表從第一個元素至最后一個元素插入到備用鏈表第一個元素前

#include"defs.h"

void DestroyList(slinklist s)
{
    int i = L[MAX-1].cur;
    L[MAX-1].cur = 0;    //令頭結點指向空
   
   int k = L[0].cur;
    L[0].cur = i;    //令備用鏈表頭結點指向鏈表第一個結點
   
    int j;       //用j來記錄鏈表最后一個結點的位序
    while (i)
     {
         j = i;
         i = L[i].cur;  //第i個結點的指針域為空，結束循環，j記錄了最后一個結點
     }
     L[j].cur = k;   //令鏈表最后一個結點指向備用鏈表第一個結點
}

7，靜態鏈表清空操作和撤銷操作是一致的。
8，判斷空操作。ListEmpty.c

#include"defs.h"

int ListEmpty(slinklist s)
{
    if (L[MAX-1].cur == 0)
        return 0;    //返回0代表為空
   else
        return 1;    //非0代表不為空
}

9，求鏈表長度操作.

#include"defs.h"

int ListLength(slinklist s)
{
    int i, j=0;
    i = L[MAX-1].cur;   //i指向第一個結點

   while (i)    //最后一個結點的指針域為空，結束循環
    {
         ++j;
         i = L[i].cur;
    }
    return j; 
}

10，取元素操作.

#include"defs.h"

int GetElem(slinklist s, int i, int *e)
{
    int j=1, k = L[MAX-1].cur; 
    if (i<1 || i>ListLength(s))  //判斷位置是否合理
       exit(0);
    while (k && j<i)   //找到第i個位置
    {
        ++j;
        k = L[k].cur;
    }
    *e = L[k].data;
    return 0;
}

11，查找元素操作實現.

#include"defs.h"

int LocateElem(slinklist s, int e)
{
    int i = L[MAX-1].cur;
    int j = 0;
    while (i)
    {
        ++j;  //j作為計數器
        if (L[i].data == e)
            return j;
        i = L[i].cur;
    }
    return 0;
}

//i僅是表示其元素的數組下標值，並不是位序

12，求前驅操作實現.

#include"defs.h"

int PriorElem(slinklist L, int cur_e, int *pri_e)
{
    int i = L[MAX-1].cur;
    int j;
    while (i)
    {
        j = L[i].cur;
        if (j && L[j].data == cur_e)
        {
              *pri_e = L[i].data;
               return 0;
        }
        i = j;
    }
    return 0;
}

13，求后繼操作的實現

#include"defs.h"

int NextElem(slinklist L, int cur_e, int *nex_e)
{
    int i = L[MAX-1].cur;
    int j;
    while (i)
    {
        j = L[i].cur;
        if (j && L[i].data == cur_e)
        {
               *nex_e = L[j].data;
                return 0;
        }
        i = j;
    }
     return 0;
}

14，Malloc函數實現

//因為沒有指針，沒有動態分配函數，所以要自己實現

#include"defs.h"

int Malloc(slinklist L)  //釋放備用鏈表第一個結點
{
    int i = L[0].cur; 
    if (i == 0)   //備用鏈表為空，無法分配，退出 
       exit(0);
    L[0].cur = L[i].cur;  //備用鏈表頭結點，指向備用鏈表第二個結點
    return  i;
}

15，Free函數實現

#include"defs.h"

void Free(slinklist L, int k) //將位置為k的空閑結點釋放
{                                    //即插入到備用鏈表第一個結點前
    L[k].cur = L[0].cur;
    L[0].cur = k;
}

//Malloc、Free均是對備用鏈表的操作

16，靜態鏈表插入操作實現

#include"defs.h"

int ListInsert(slinklist L, int i, int e)
{
    int k = L[MAX-1].cur;  //k指向第一個結點
   int j = 1, m, s;

    if (i<1 || i>ListLength(L)+1)  //判斷位置是否合理
       exit(0);
    
    while (k && j<i-1)  //找到第i-1個位置
    {
          ++j;
          k = L[k].cur;
    }
    m = L[k].cur;   //m指向第i個位置
   
   s = Malloc(L);  //分配一個結點s
    L[s].data = e;
    L[s].cur = L[m].cur; 
    L[k].cur = s;
    return 0;
}

17，靜態鏈表刪除操作的實現

#include"defs.h"

int ListDelete(slinklist L, int i, int *e)
{
     int k = L[MAX-1].cur;
     int j = 1, m;
     if (i<1 || i>ListLength(L))  //判斷位置是否合理
        exit(0);

     while (k && j<i-1)  //找到第i-1個位置
     {
         ++j;
         k = L[k].cur;
     }
     m = L[k].cur;  //m指向第i個位置
    *e = L[m].data;
     L[k].cur = L[m].cur;
     Free(L, m); //將空閑結點m釋放到備用鏈表中    
}

18，遍歷靜態鏈表操作實現

#include"defs.h"

void TravelList(slinklist L)
{
    int j = 0;
    int i = L[MAX-1].cur;
    
    while (i)
    {
         ++j;
         printf("第%d個結點為：%d\n", j, L[i].data);
         i = L[i].cur;
    }
}