静态链表结构：

我们对数组的第一个和最后一个元素做特殊处理，不存数据。第一个元素的cur存放备用链表的第一个结点的下标，最后一个元素存放含有值的第一个元素的下标，相当于头结点的作用。

当链表为空时，最后一个下标的cur为0

当链表满了时，第一个下标的cur为MAXSIZE-1，即指向最后一个单元的地址

 
  
  1. #define MAXSIZE 1000 
  2.  
  3. typedef struct{ 
  4.     ElemType data; 
  5.     int cur; 
  6. }Component,StaticLinkList[MAXSIZE]; 
 
  
静态链表的初始化：
 
  
 
  
  1. void initList(StaticLinkList space){ 
  2.     int index; 
  3.     for(index=0;index<MAXSIZE-1;index++){ 
  4.         space[index].cur = index+1; 
  5.     } 
  6.     space[MAXSIZE-1].cur = 0; 
  7. } 
 
  
静态链表的插入
 
  
 
  
  1. int mallocSLL(StaticLinkList space){ 
  2.     int i; 
  3.      
  4.     if(space[0].cur == MAXSIZE-1){//表满了，返回0  
  5.         i = 0; 
  6.         return i; 
  7.     } 
  8.     else{ 
  9.         i = space[0].cur;//取出备用链表第一个元素  
  10.         space[0].cur = space[i].cur;//重新修改备用链表的第一个元素  
  11.         return i;  
  12.     } 
  13. } 
 
  
 
  
 
  
  1. bool StaticLinkListInsert(StaitcLinkList space,int i,ElemType e){ 
  2.     int j;//新分配元素的下标 
  3.     int index;//计数器 
  4.     int k;//游标  
  5.       
  6.       
  7.     if(i<1 || i>listLength(L)+1)//如果i的取值范围不合适，插入到底i个元素的前面，i取值为[1,length+1]  
  8.         return false; 
  9.     j = mallocSLL(L); 
  10.     if(j){//不成功说明表满了  
  11.         k = MAXSIZE - 1;//让游标指向第一个数值位置的前一个位置  
  12.         for(index=1;index<=i-1;index++){ 
  13.             k = space[k].cur; 
  14.         } 
  15.         space[j].data = e;//将新元素赋值  
  16.         space[j].cur = space[k].cur;//更改cur指向  
  17.         space[k].cur = j;//顺序不能错  
  18.         return true; 
  19.     } 
  20.     else{ 
  21.         return false; 
  22.     } 
  23.      
  24. } 
 
  
静态链表的删除
 
  
 
 
  
 
  
  1. bool StaticLinkListDelete(StaticLinkList space,int i){ 
  2.     int index;//计数器 
  3.     int k;//游标 
  4.     int j;//指向被删除的元素  
  5.      
  6.     k = MAXSIZE-1;//k指向被删除元素的上一个元素  
  7.     if(space[k].cur){//表空  
  8.         return false; 
  9.     }  
  10.     if(i<1 || i>listLength(L)){//删除位置必须要合理  
  11.         return false; 
  12.     } 
  13.     for(index=1;index<=i-1;index++){//找到删除的位置  
  14.         k = space[k].cur; 
  15.     } 
  16.     j = space[k].cur;//交换指针 
  17.     space[k].cur = space[j].cur; //修改被删除元素的上一个元素的cur值   
  18.     freeSLL(L,j);//修改备用链表  
  19.     return true; 
  20. } 
 
  
 
 
  
 
  
  1. void freeSLL(StaticLinkList space,int j){ 
  2.     space[j].cur = space[0].cur;  
  3.     space[0].cur = j; 
  4. } 
 
  
静态链表的长度
 
  
 
 
  
 
  
  1. int listLength(StaticLinkList L){//如果下一个位置为空，则cur为0  
  2.     int count = 0; 
  3.      
  4.     int i = L[MAXSIZE-1].cur; 
  5.     while(i){ 
  6.         i = L[i].cur; 
  7.         count++; 
  8.     } 
  9.     return count; 
  10. } 
 
  
 静态链表的特点