#define MAXSIZE 1000
#define OK 1
#define ERROR 0
typedef int Status;
typedef int ElemType;

typedef struct
{
    ElemType data;                    // 存放数据元素
    int cur;                          // 当前位置
} Component, StaticLinkList[MAXSIZE]; // 定义静态链表

//初始化静态链表
Status InitList(StaticLinkList space)
{
    int i;
    for (i = 0; i < MAXSIZE; i++)
    {
        space[i].cur = i + 1; // 初始化每个结点的cur域
    }
    space[MAXSIZE - 1].cur = 0; // 将最后一个元素的cur设置为0
    return OK;
}

//静态链表的插入操作
Status ListInsert(StaticLinkList L, int i, ElemType e)
{
    int j, k, l;
    k = MAXSIZE - 1;
    if (i < 1 || i > ListLength(L))
    {
        return ERROR;
    }
    j = Malloc_SSl(L); // 获取空闲节点的位置
    if (!j)
    {
        L[j].data = e; // 将数据元素赋值给空闲节点
        for (l = 1; l <= i - 1; l++)
        {
            k = L[k].cur;
        }
        L[j].cur = L[k].cur;
        L[k].cur = j;
        return OK;
    }
    return ERROR;
}

//静态链表删除操作
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;
}

// 若备用链表非空，则返回分配的节点下标，否则返回0
int Malloc_SSl(StaticLinkList space)
{
    int i = space[0].cur; // 获取当前数组返回第一个元素的cur域
    if (space[0].cur)     //如果存在
    {
        space[0].cur = space[i].cur; // 将空闲节点的cur域赋值给头元素的cur域
    }
    return i; // 返回空闲节点的位置
}

//将下标为i的空闲节点回收到备用链表
void Free_SSl(StaticLinkList L, int i)
{
    L[i].cur = L[0].cur;
    L[0].cur = i;
}

// 返回长度
int ListLength(StaticLinkList L)
{
    int j = 0;
    int i = [MAXSIZE - 1].cur;
    while (i)
    {
        i = L[i].cur;
        j++;
    }
    return j;
}

/*
 *  静态链表优点：插入和删除的时候只需要修改游标，不需要移动元素，从而改进了顺序存储结构中插入和删除操作需要移动大量元素的缺点。
    静态链表缺点：没有解决连续存储分配带来的表长难以确定的问题，失去了链式存储结构随机存储的特性。
 * 
 * /

静态链表其实是为了给没有指针的高级语言设计的一种实现单链表能力的方法。很少用，但是也可以学习其思想。(｡◕ˇ∀ˇ◕)