数据结构-静态链表

如图：

 

1、静态链表是由游标和数据构成的结构体数组（类似链表 ）；

2、下标为0 的链表结点，游标存储指向首个没有存储数据的链表结点下标（即5）（头指向尾）；

3、下标链表max(即999)的链表结点，游标存储 首个存储有数据的链表结点（即1）的下标（尾指向头）；

4、前一个链表结点的游标存储下一个逻辑相邻结点的下标；

5、最后一个存储有数据的链表结点的游标为0；

模拟插入数据

#include <bits/stdc++.h>
using namespace std;
typedef  int   ElemType;
typedef  int   status;
#define MAXSIZE 1000
#define OK 1;
#define ERROR 0;
typedef struct  {
    ElemType data; 
    int cur;
    
} component,StaticLinkList[MAXSIZE];

status InitList(StaticLinkList space){  //建立空表 
    
    for(int i = 0;i<MAXSIZE-1;i++){
        space[i].cur = i+1 ; // 空表，所以space[0].cur 存放1 
        
    } 
    space[MAXSIZE-1].cur = 0;  //原因同上 
    return OK; 
}

int New_SLL(StaticLinkList space){   //获取一个空的链表结点，整个静态链表做出相应的调整 
    int i=space[0].cur;  //i 表示 空链表的下标 
    if(space[0].cur){
        space[0].cur = space[i].cur;  //space[i].cur 存放的是下一个未存放数据的结点下标，给了space[0].cur,作为未用链表的开头 
    } 
    return i; 
    } 

int ListLength(StaticLinkList L){
    int len = 0;
    int  i= L[MAXSIZE-1].cur; 
    while(i){
        i = L[i].cur;
        len++; 
    }
    return len;
}

status ListInsert(StaticLinkList L,int i,ElemType e) {
    int j,k,l;
    k = MAXSIZE - 1; //k表示 
    if(i<1||i>ListLength(L)+1){
        return ERROR;
        
    }
    j = New_SLL(L); 
    if(j){
        L[j].data = e;
        for(l= 1;l<=i-1;l++ ){   //for循环找到 插入的结点前一个结点，从链表开头开始循环查找 
            k = L[k].cur;
        }
        L[j].cur = L[k].cur;   //把插入的结点游标置为前一个结点游标存储的下标，即插入的游标下一个链接的是原来前一个结点原来下一个节点 
         L[k].cur = j;   //前一个结点的游标存储的是插入结点的下标 
         return OK;
    }
    return ERROR;
}

   void Free_SSL(StaticLinkList space, int k)
   {
        space[k].cur=space[0].cur; // space[0].cur 存放原来第一个空闲结点的游标，现在空闲的第一个结点下标是K， 所以，现在 space[k].cur 存放原来的下标 
        space[0].cur = k;  
   }
   
   
   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;//j是删除项的下标    
        L[k].cur = L[j].cur;  //前一项的游标（存储删除项下标）赋值成删除项的游标（存储下一项的下标） 
        Free_SSL(L,j);
        return OK;

}


void TravelList(StaticLinkList L)
{
    int j = 0;
    int i = L[MAXSIZE-1].cur;
    
    while (i)
    {
         ++j;
         printf("第%d个结点为：%d\n", j, L[i].data);
         i = L[i].cur;
    }
}



int main(){
    StaticLinkList L1;
     InitList( L1);
     
     for(int i=1;i<=10;i++){
      L1[i].data = i;
     }
     
     L1[999].cur=1;
     L1[10].cur = 0;
     L1[0].cur = 11;
       
       
 TravelList(L1);
   
    
    cout<<L1[999].cur<<endl;
    
     cout<<"长度为："<<ListLength(L1);
     ListInsert(L1,2,0);
     TravelList(L1);
     ListDelete(L1,2);
     TravelList(L1);
    return 0;
}