01--数据结构——静态链表

#include <stdio.h>  
  
const int OK = 1;  //定义正确返回  
const int ERROR  = -1;  //定义错误的返回  
const int OVERFLOW = -2; //定义溢出  
  
#define MAXSIZE 1000  //链表的最大长度  
  
//定义元素类型  
typedef int ElemType;  
//定义返回类型  
typedef int Status;  
  
//定义结点  
typedef struct{  
    ElemType data;  
    int cur; //下一个元素的下标  
}component, SLinkList[MAXSIZE];  
  
//获取链表元素e的下标  
int LocateElem_SL(SLinkList S, ElemType e){  
    int i = S[0].cur; //S[0]是头结点  
    while(i && S[i].data != e){  
        i = S[i].cur;  
    }  
    return i;  
}  
  
//初始化一个链表(备用空间）  
void InitSpace_SL(SLinkList &space){  
    int i;  
    for(i=0; i<MAXSIZE-1; ++i)  
        space[i].cur = i+1;  
    space[MAXSIZE-1].cur = 0;  
}  
  
//获取头结点  
int Malloc_SL(SLinkList &space){  
    int i = space[0].cur; //获取头结点  
    //判断备用空间链表非空（如果是空则i=0,直接返回0，否则返回分配结点的下标）  
    if(space[0].cur) {  
        //下一个结点作为头结点  
        space[0].cur = space[i].cur;  
    }  
    return i;  
}  
  
//显示链表  
void Show_SL(SLinkList &space){  
    printf("链表的打印结果是\n");  
    int s = Malloc_SL(space); //指向头结点  
    while(space[s].cur != 0){  
        s = Malloc_SL(space);  
        printf("%d\n", space[s].data);  
    }  
    printf("\n");  
}  
  
//将下标为k的空闲结点回收到备用空间（相当于头插法，插入备用空间）  
void Free_SL(SLinkList &space, int k){  
    space[k].cur = space[0].cur;  
    space[0].cur = k;  
}  
  
//依次输入集合A和集合B的元素，在一维数组space中建立表示集合（A-B）U(B-A)  
//的静态链表，S为其头指针，假设备用空间足够大，space[0].cur为其头指针  
void difference(SLinkList &space, int &S){  
    InitSpace_SL(space);  //初始化备用空间  
    S = Malloc_SL(space);  //生成S的头结点  
    int r = S;  
    printf("请输入A,B集合的元素个数,用逗号隔开\n");  
    int m,n;  
    scanf("%d,%d", &m, &n);  
    int i,j;  
    printf("请依次输入A集合的元素并按回车\n");  
    int nn;  
    //给A集合添加数据  
    for(j=1; j<=m; ++j){  
        i = Malloc_SL(space); //取出下一个空间索引  
        scanf("%d", &nn); //赋值  
        space[i].data = nn;  
        space[r].cur = i;  //尾插法（r指向的是最后一个结点，让上一次最后结点指向i索引）  
        r = i;     //r指向最后的节点  
    }  
  
    space[r].cur = 0;  //将最后一个结点指向空（也就是0）  
    printf("请依次输入B集合的元素\n");  
    int b;  
    int p;  
    int k;  
    for(j = 1; j<=n; ++j){  
        scanf("%d", &b); //读取并记录到临时变量b  
        p = S;  //记录头结点  
        k = space[S].cur;  //k指向第一个结点  
        while(k != space[r].cur && space[k].data != b){  
            p = k;  
            k = space[k].cur; //指向下一个结点  
        }  
        if(k == space[r].cur){  //不存在元素b,插入到r所指结点之后  
            i = Malloc_SL(space);  
            space[i].data = b;  
            space[i].cur = space[r].cur;  
            space[r].cur = i;  
        }else{  //存在元素b，删除  
            space[p].cur = space[k].cur;  
            Free_SL(space, k);  
            if(r == k) r = p;  
        }  
    }  
    //指回头指针  
    space[0].cur = S;  
}  
  
int main(){  
    SLinkList sl;  
    int s;  
    difference(sl, s);  
    Show_SL(sl);  
    printf("finish....\n");  
    scanf("%d");  
    return 0;  
}  

这种描述方法便于在不设“指针”类型的高级程序设计语言中使用链表结构，这种用数组描述的链表叫静态链表。