—— 头文件

#include <stdio.h>
#define maxSize 6

结构体声明静态链表节点

// 结构体声明静态链表节点
typedef struct {
    int data;  //数据域
    int cur;  // 游标
} component;

构建创建静态链表的函数（包括备用链表）

// 创建备用链表
void reserveArr(component *array){
    for (int i = 0; i < maxSize; i++) {
        array[i].cur = i + 1;  // 将每个数组分量链接到一起
        array[i].data = -1;
    }
    array[maxSize-1].cur = 0;  // 链表最后一个结点的游标值为 0
}

// 提取分配空间
int mallocArr(component *array){
    // 若备用链表非空，则返回分配的结点下标，否则返回 0（当分配最后一个结点时，该结点的游标值为 0）
    int i = array[0].cur;
    if (array[0].cur) {
        array[0].cur = array[i].cur;  
    }
    return i;  // 1 2 3 4 5 0
}

// 初始化静态链表
int initArr(component *array, int length){
    reserveArr(array);
//    int body = mallocArr(array);  // 1
	int body = 1;
    int tempBody = body;  // 1 
    for (int i = 1; i < length + 1; i++) {
        int j = mallocArr(array);  // 1
        array[tempBody].cur = j+1;  
        array[tempBody].data = i;  
        tempBody = j+1; 
    }
//    for (int i = 1; i < length + 1; i++) {
//        int j = mallocArr(array);  
//        array[tempBody].cur = j;  
//        array[tempBody].data = i;  
//        tempBody = j; 
//    }
    array[tempBody-1].cur = 0;
//    array[0].cur--;
    return body;
}

构造展示静态链表元素的函数

// 输出静态链表中的元素
void displayArr(component *array, int body){
    int tempBody = body;  // tempBody准备做遍历使用
    printf("静态链表为：");
    while (array[tempBody].cur) {
        printf("%d,%d ", array[tempBody].data, array[tempBody].cur);
        tempBody = array[tempBody].cur;
    }
    printf("%d,%d\n", array[tempBody].data, array[tempBody].cur);
}

构造插入静态链表元素的函数

// 插入元素到静态链表中 
void insertArr(component *array, int body, int position, int elem){
	int tempBody = body;
	// 找到要插入位置的上一个节点所在位置 
	for(int i = 1; i < position - 1; i++){
		tempBody = array[tempBody].cur;  // 2
	} 
	// 提取空间 
	int insert = mallocArr(array);  // 4
//	printf("%d\n", insert);
	// 插入数据
	array[insert].data = elem;
	
	// 连接静态链表
	array[insert].cur = array[tempBody].cur;  // 3
	array[tempBody].cur = insert;  // 4
}

构造删除静态链表元素的函数

// 用于备用链表回收空间（k表示未使用节点所在数组的下标） 
void freeArr(component * array, int k){
    array[k].cur = array[0].cur;
    array[0].cur = k;
}

// 用于删除静态链表的结点（elem 表示待删除节点的数据域中存放的数据） 
void deletArr(component *array, int body, int elem){
    int tempBody = body;
    // 找到被删除结点的位置
    while (array[tempBody].data != elem) {
        tempBody = array[tempBody].cur;
        // 当 tempBody为 0时，表示链表遍历结束，说明链表中没有存储该数据的结点
        if (tempBody == 0) {
            printf("链表中没有此数据");
            return;
        }
    }
    //运行到此，证明有该结点
    int del = tempBody;  // 4 2
    
	tempBody = body;  // 1 1
    //找到该结点的上一个结点，做删除操作
    while (array[tempBody].cur != del) {
        tempBody = array[tempBody].cur; // 2 1
    }
    //将被删除结点的游标直接给被删除结点的上一个结点
    array[tempBody].cur = array[del].cur;
    //回收被摘除节点的空间
    freeArr(array, del);
}

构造查找静态链表元素的函数

// 查找静态链表元素
int selectElem(component *array, int body, int elem){
	int tempBody = body;
	while(array[tempBody].cur != 0){
		if(array[tempBody].data == elem){
			return tempBody;
		}
		tempBody = array[tempBody].cur;
	}
	return -1;
}

构造更新静态链表元素的函数

// 更新静态链表元素
void updateElem(component *array, int body, int oldelem, int newelem){
	int position = selectElem(array, body, oldelem);
	if(position == -1){
		printf("无更改元素\n");
        return;
	}
	array[position].data = newelem;
}

—— 主函数

int main() {
    component array[maxSize];
    int body = initArr(array, 3);
    displayArr(array, body);  // 静态链表为：1,2 2,3 3,0
    
    insertArr(array, 1, 3, 4);
    displayArr(array, body);  // 静态链表为：1,2 2,4 4,3 3,0
    
    deletArr(array, 1, 2);
    displayArr(array, body);  // 静态链表为：1,4 4,3 3,0
    
    printf("其索引下标为：%d\n", selectElem(array, 1, 4));  // 其索引下标为：4
    
    updateElem(array, 1, 4, 100); 
    displayArr(array, body);  // 静态链表为：1,4 100,3 3,0
    return 0;
}