靜態鏈表的C實現和核心點(基於數據結構 嚴蔚敏)

靜態鏈表是利用一維數組實現邏輯上的單鏈表結構，結點的邏輯上相鄰但物理位置上不一定相鄰，因為內存分配上是一次性的，故稱為靜態。

特點：

• 預先需要一片連續的存儲空間；
• 非隨機存取；
• 無現成的“內存”分配和回收函數，得自己實現；
• 最多存儲MAXSIZE - 1個數據；

核心包含了兩個鏈表：

• 數據鏈表(初始化完成后需記住頭結點,一般為數組的第1個分量)
• 備用的空閑鏈表(數組的第0個分量是備用鏈表的頭結點)
• 注意邏輯位序和物理位序，實際上並沒有利用物理位序的使用操作，牢牢記住它只是一個單鏈表

這兩個鏈表都需要自己維護。

核心函數 :

• "內存"申請函數 int Malloc_SL()；該函數返回申請的結點下標。
• "內存"釋放函數void Free_SL(int k);釋放邏輯位序k。

注意函數:

• void InitSpace_SL();該函數初始化鏈表空間,不做其他操作；
• int InitList_SL(SLinkList *h);該函數初始化數據鏈表並返回數據鏈表的頭結點,這個頭結點h非常重要,書本上沒有這個函數的介紹,導致有些人搞不懂對數據鏈表的操作該如何進；

Status.h文件

#ifndef STSTUS_H
#define STSTUS_H

#define TRUE    1    //真
#define FALSE    0    //假

#define YES    1    //是
#define NO    0    //否

#define OK    1    //通過
#define ERROR    0    //錯誤

#define SUCCESS    1    //成功
#define UNSUCCESS    0    //失敗
#define INFEASIBLE    -1    //不可行

#define OVERFLOW    -2    //堆棧上溢
#define UNDERFLOW    -3    //堆棧下溢

typedef int Status;

#define PressEnter \
{\
fflush(stdin);\
printf("Press Enter...");\
getchar();\
fflush(stdin);\
}

#endif

StaticLinkedList.h文件

#ifndef STATICLINKEDLIST_H_
#define STATICLINKEDLIST_H_

#include "Status.h"

#define MAXSIZE 30
typedef int ElementType;
typedef int SLinkList;

typedef struct
{
    ElementType data;
    int cur;
}Component[MAXSIZE];



//初始化,將一維數組Space中各分量鏈成一個大的備用空間
void InitSpace_SL();

//為插入的輸入申請空間,從備用空間取得一個結點,返回分配結點下標
int Malloc_SL();

//將下標為k的空閑結點回收
void Free_SL(int k);

//初始化靜態鏈表,建立頭結點,返回頭結點下標
int InitList_SL(SLinkList *h);

//置空
Status ClearList_SL(SLinkList h);

//銷毀
void DestroyList_SL(SLinkList* h);

//判空
Status ListEmpty_SL(SLinkList h);

//求長
int ListLength_SL(SLinkList h);

//取值
//h--頭結點,i--邏輯位置(1->maxsize-2),e--返回值
Status GetElem_SL(SLinkList h, int i, ElementType* e);

//返回元素e的位序
int LocateElem_SL(SLinkList h, ElementType e);

//前驅
//找值為cur_e的結點的前一個結點的值
Status PriorElem_SL(SLinkList h, ElementType cur_e, ElementType* pre_e);

//后繼
Status NextElem_SL(SLinkList h, ElementType cur_e, ElementType* next_e);

//插入
//在邏輯上第i個位置前插入數據,使其成為第i個位置
//i從1開始
Status ListInsert_SL(SLinkList h, int i, ElementType e);

//刪除
Status ListDelete_SL(SLinkList h, int i, ElementType* e);

//遍歷
Status ListTraverse_SL(SLinkList h, void(Visit)(ElementType));

#endif

StaticLinkedList.cpp文件

#include "stdafx.h"
#include <cstdlib>

#include "StaticLinkedList.h"

//定義靜態鏈表空間
Component Space;

void InitSpace_SL()
{    //初始化備用空間,形成備用鏈表
    
    for (size_t i = 0; i < MAXSIZE - 1; ++i)    //將0號單元做備用空間的起始結點
    {
        Space[i].cur = i + 1;    //各空間結點邏輯上首尾相連
    }
    Space[MAXSIZE - 1].cur = 0; //最后一個結點下標指向NULL = 0,相當於鏈表的尾指針
}

int Malloc_SL()
{
    int i = Space[0].cur;

    if (Space[0].cur)
    {
        //將申請到的空間從備用鏈表空間中斷開,並為下一個空閑結點做准備，即將下一個空閑結點鏈接到s[0]下
        Space[0].cur = Space[i].cur;
        return i;                     //返回申請到的空間下標
    }
    return 0;    //申請失敗返回0
}

void Free_SL(int k)
{
    Space[k].cur = Space[0].cur;    //將k結點的下個結點置為備用鏈表的第一個結點
    Space[0].cur = k;    //將K結點置為備用空間的第一個結點
}

 38 int InitList_SL(SLinkList * h)
 39 {
 40     *h = Malloc_SL();    //創建頭結點
 41     if (!(*h))
 42     {
 43         exit(OVERFLOW);    //空間已滿
 44     }
 45 
 46     Space[*h].cur = 0;    //頭結點游標置為0
 47     return OK;
 48 }

Status ClearList_SL(SLinkList h)
{
    int p;
    if (!h)
    {
        return ERROR;
    }
    p = Space[h].cur; //p指向第一個結點
    while (p)
    {
        Space[h].cur = Space[p].cur; //從數據鏈表首結點開始刪除
        Free_SL(p);
        p = Space[h].cur;
    }

    return OK;
}

void DestroyList_SL(SLinkList * h)
{
    ClearList_SL(*h);
    Free_SL(*h);    //釋放頭結點
    *h = 0;
}

Status ListEmpty_SL(SLinkList h)
{
    if (h && !Space[h].cur)
    {
        return TRUE;
    }
    return FALSE;
}

int ListLength_SL(SLinkList h)
{
    if (!h)
    {
        exit(OVERFLOW);
    }

    int count, p;
    count = 0;
    p = Space[h].cur;
    while (p)
    {
        count++;
        p = Space[p].cur;
    }
    return count;
}

Status GetElem_SL(SLinkList h, int i, ElementType * e)
{
    //-2 去掉備用頭結點和數組溢出兩個
    if (!h || i < 1 || i > MAXSIZE - 2) 
    {
        return ERROR;
    }

    int count, p;
    count = 0;
    p = Space[h].cur;
    while (p)
    {
        count++; //先++,從第一個邏輯位置開始,count很重要,尋找操作都需要count計數
        if (count == i)
        {
            *e = Space[p].data;
            return OK;
        }
        p = Space[p].cur;
    }
    return ERROR;
}

int LocateElem_SL(SLinkList h, ElementType e)
{
    int k, count;
    count = 1;
    if (h && Space[h].cur) //不為空表
    {
        k = Space[h].cur;
        while (k && Space[k].data != e)
        {
            count++;
            k = Space[k].cur;
        }
        if (k)
        {
            return count;
        }
    }
    return 0;
}

Status PriorElem_SL(SLinkList h, ElementType cur_e, ElementType * pre_e)
{
    int p, q;
    if (h)
    {
        p = Space[h].cur;
        if (p && Space[p].data != cur_e)
        {
            q = Space[p].cur;
            while (q && Space[q].data != cur_e)
            {
                p = q;        //用p記住前驅
                q = Space[q].cur;
            }
            if (q)
            {
                *pre_e = Space[q].data;
                return OK;
            }
        }
    }
    return ERROR;
}

Status NextElem_SL(SLinkList h, ElementType cur_e, ElementType * next_e)
{
    int p;
    if (h)
    {
        p = Space[h].cur;
        if (p && Space[p].data != cur_e)
        {
            p = Space[p].cur;

            if (p && Space[p].cur)
            {
                p = Space[p].cur;
                *next_e = Space[p].data;
                return OK;
            }
        }
    }
    return ERROR;
}

Status ListInsert_SL(SLinkList h, int i, ElementType e)
{
    if (!h)
    {
        return ERROR;
    }

    int count, k, p;
    if (i > 0) //
    {
        count = 0;
        k = h;

        while (k && count < i - 1) //找到邏輯插入位置的前一個位置
        {
            count++;
            k = Space[k].cur;
        }
        if (k)    //找到第i-1個元素位置
        {
            p = Malloc_SL();
            if (!p)
            {
                return ERROR;
            }
            Space[p].data = e;
            Space[p].cur = Space[k].cur;
            Space[k].cur = p;

            return OK;
        }
    }
    return ERROR;
}

Status ListDelete_SL(SLinkList h, int i, ElementType * e)
{
    if (!h)
    {
        return ERROR;
    }
    
    int count, k, p;
    if (i > 0)
    {
        count = 0;
        k = h;
        while (k && count < i -1) //找到刪除位置的前一個位置
        {
            count++;
            k = Space[k].cur;
        }

        if (k && Space[k].cur)  //找到第i-1個元素卻不是尾結點
        {
            p = Space[k].cur;    //p指向第i結點
            *e = Space[p].data;
            Space[k].cur = Space[p].cur;
            Free_SL(p);

            return OK;
        }
    }
    return ERROR;
}

Status ListTraverse_SL(SLinkList h, void(Visit)(ElementType))
{
    if (!h)
    {
        return ERROR;
    }
    
    int p = Space[h].cur;
    while (p)
    {
        Visit(Space[p].data);
        p = Space[p].cur;
    }

    return OK;
}

Main函數

void PrintElem(ElementType e)
{
    printf("%d ", e);
}

int main()
{
    SLinkList h; //數據鏈表頭結點,全局
    ElementType e;
    int i;

    printf("初始化靜態鏈表的備用空間Space....");
    InitSpace_SL();
    printf("\n");
    PressEnter;

    printf("初始化靜態鏈表頭結點H,申請空間....");
    InitList_SL(&h);
    printf("\n");
    PressEnter;

    ListEmpty_SL(h) ? printf("h為空!\n") : printf("h不為空!\n");
    printf("\n");
    PressEnter;

    for (size_t j = 1; j < 6; ++j)
    {
        printf("在h第%d個位置插入%d\n", j, 2 * j);
        ListInsert_SL(h, j, 2 * j);
        printf("\n");
    }
    printf("h中的元素為:h=");
    ListTraverse_SL(h, PrintElem);
    printf("\n");
    PressEnter;

    printf("h的長度為%d\n", ListLength_SL(h));
    printf("\n");
    PressEnter;

    ListDelete_SL(h, 4, &e);
    printf("刪除h中第 4 個元素 %d,用Free_SL釋放空間....", e);
    printf("\n");
    PressEnter;

    printf("刪除后h中的元素為:h=");
    ListTraverse_SL(h, PrintElem);
    printf("\n");
    PressEnter;

    printf("元素8在h中的位序為%d\n",LocateElem_SL(h,8));
    printf("\n");

    printf("清空h前:");
    ListEmpty_SL(h) ? printf("h為空!\n") : printf("h不為空!\n");
    ClearList_SL(h);
    printf("清空h后:");
    ListEmpty_SL(h) ? printf("h為空!\n") : printf("h不為空!\n");
    printf("\n");
    PressEnter;

    printf("銷毀h前:");
    h ? printf("h存在!\n") : printf("h不存在!\n");
    DestroyList_SL(&h);
    printf("銷毀h后:");
    h ? printf("h存在!\n") : printf("h不存在!\n");
    printf("\n");
    PressEnter;

    return 0;
}