静态链表

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define MYOVERFLOW -2
#define MAXSIZE 1000//链表的最大长度
typedef int Status;
typedef int Elemtype;//用指定标识符Elemtype代表int类型，顾名思义表示元素类型为int型
typedef struct{
    Elemtype data;
    int cur;
}component, SLinkList[MAXSIZE];

void InitSpace_SL(SLinkList &space);//将一维数组space中个分量链成一个备用链表，space[0].cur为头指针
                                    //“0”表示空指针 
int Malloc_SL(SLinkList &space);//若备用空间链表非空，则返回分配的结点下标，否则返回0
void Free_SL(SLinkList &space, int k);//将下标为k的空闲结点回收到备用链表
void Creat_SL(int &,SLinkList &);//创建一个静态链表，包含一个头结点，头结点的数据域为0
void Traverse_SL(int SL,SLinkList );//对静态链表SL进行遍历
int LocateElem_SL(SLinkList , Elemtype e);
//在静态单恋线性表L中查找第一个值为e的元素
//若找到，则返回它在L中的位序,否则返回0
void difference(SLinkList &space, int &S);
//依次输入集合A和B的元素，在一维数组space中建立表示集合（A-B)U（B-A）
//的静态链表，S为其头指针，假设设备空间足够大，space[0].cur为其头指针

void InitSpace_SL(SLinkList &space)//将一维数组space中个分量链成一个备用链表，space[0].cur为头指针
                                   //“0”表示空指针
{
    for (int i = 0; i < MAXSIZE - 1; i++)space[i].cur = i + 1;
    space[MAXSIZE - 1].cur = NULL;
}
int Malloc_SL(SLinkList &space)//若备用空间链表非空，则返回分配的节点下标，否则返回0
{
    int i = space[0].cur;
    if (space[0].cur)space[0].cur = space[i].cur;
    return i;
}
void Free_SL(SLinkList &space, int k)//将下标为k的空闲结点回收到备用链表
{
    space[k].cur = space[0].cur;
    space[0].cur = k;
}
void Creat_SL(int &SL,SLinkList &space)//创建一个静态链表，包含一个头结点，头结点的数据域为0
{
    int n;
    cout << "please input the length of the list:";
    cin >> n;
    SL = Malloc_SL(space);//创建头结点，头结点的数据域为NULL
    int pt = SL;
    space[SL].data = NULL;
    cout << "please input the data of the node:";
    for (int i = 1; i <= n; i++){//创建后面N个带数据的结点
        int temp = Malloc_SL(space);
        cin >> space[temp].data;
        space[SL].cur = temp;//使结点向后移
        SL = temp;
    }
    space[SL].cur=NULL;//最后一个结点的指针域为0
    SL = pt;
    cout << "The creation of list is completed!" << endl;
}
void Traverse_SL(int SL,SLinkList space)//对静态链表SL进行遍历
{
    cout << "the contain of  the list is :" << endl;
    SL = space[SL].cur;
    for (;SL;){
        cout << space[SL].data << " ";
        SL = space[SL].cur;
    }
    cout << endl;
}
int LocateElem_SL(SLinkList space, Elemtype e)
//在静态单恋线性表L中查找第一个值为e的元素
//若找到，则返回它在L中的位序,否则返回0
{
    int i = 2;
    for (; space[i - 1].cur; i = space[i].cur)
    if(space[i].data == e &&space[i - 1].cur){
        return i - 1;
    }
    return 0;
}
void difference(SLinkList &space, int &S)
//依次输入集合A和B的元素，在一维数组space中建立表示集合（A-B)U（B-A）
//的静态链表，S为其头指针，假设设备空间足够大，space[0].cur为其头指针
{
    S = Malloc_SL(space);
    space[S].data = NULL;//建立头结点
    int r = S;
    int la, lb;
    cout << "please input the length of A and B :";
    cin >> la >> lb;
    cout << "please input the data of A:" << endl;
    for (int i = 1; i <= la; i++){//输入A的值
        int temp = Malloc_SL(space);
        cin >> space[temp].data;
        space[r].cur = temp;
        r = temp;
    }
    space[r].cur = NULL;//r是当前最后一个结点
    cout << "please input the data of B:" << endl;
    for (int j = 1; j <= lb; j++){//输入B的值
        int temp = Malloc_SL(space);
        cin >> space[temp].data;
        int p;
        p = S;
        int k = space[p].cur;
        while (k&&space[k].data != space[temp].data){//判断输入的B的值是否是A中的元素
            p = k;                                   //p是k的先驱结点，进行插入和删除操作需要用到前驱结点
            k = space[k].cur;
        }
        if (!k){                                   //不是A中的元素直接插入到A的末尾此时p是最后一个元素
            space[temp].cur = space[p].cur;
            space[p].cur = temp;
        }
        else{                                    //是A中的元素，先释放临时建立的结点
            Free_SL(space, temp);
            if (k != r){                        //删除A中与B中元素想对象的点
                space[p].cur = space[k].cur;
                Free_SL(space, k);
            }
            else {
                space[p].cur = space[k].cur;
                Free_SL(space, k);
                r = p;                        //如果删除的是最后一个元素，则r的值要改变
            }
        }
    }
}