静态链表（图解 实现 对比）

静态链表（图解 实现 对比）

数组结构

索引 | data | next
0    | ...  | 1
1    | ...  | 2
2    | ...  | 3
3    | ...  | 4
4    | ...  |-1

初始状态：freeHead=0，usedHead=-1

代码实现

#include <stdio.h>
#define MAX_SIZE 5

typedef struct {
    int data;
    int next;
} Node;

Node staticList[MAX_SIZE];
int freeHead;
int usedHead;

// 初始化静态链表
void initialize() {
    for (int i = 0; i < MAX_SIZE - 1; i++) {
        staticList[i].next = i + 1;
    }
    staticList[MAX_SIZE - 1].next = -1;
    freeHead = 0;
    usedHead = -1;
}

// 在链表头部插入元素
int insert(int data) {
    if (freeHead == -1) return -1; // 链表已满

    int newNode = freeHead;
    freeHead = staticList[newNode].next;

    staticList[newNode].data = data;
    staticList[newNode].next = usedHead;
    usedHead = newNode;
    return 0;
}

// 删除指定数据的节点
int delete(int data) {
    int current = usedHead;
    int prev = -1;

    while (current != -1) {
        if (staticList[current].data == data) {
            if (prev == -1) { // 删除头节点
                usedHead = staticList[current].next;
            } else {
                staticList[prev].next = staticList[current].next;
            }
            // 回收节点到空闲链表
            staticList[current].next = freeHead;
            freeHead = current;
            return 0;
        }
        prev = current;
        current = staticList[current].next;
    }
    return -1; // 未找到
}

// 遍历链表
void traverse() {
    int current = usedHead;
    while (current != -1) {
        printf("%d -> ", staticList[current].data);
        current = staticList[current].next;
    }
    printf("NULL\n");
}

// 调试信息：打印数组详情
void debugPrint() {
    printf("Index | Data | Next\n");
    for (int i = 0; i < MAX_SIZE; i++) {
        printf("%5d | %4d | %4d\n", i, staticList[i].data, staticList[i].next);
    }
    printf("usedHead: %d, freeHead: %d\n", usedHead, freeHead);
}

int main() {
    initialize();
    insert(10);
    insert(20);
    insert(30);
    printf("After inserts:\n");
    traverse();
    debugPrint();

    delete(20);
    printf("\nAfter deleting 20:\n");
    traverse();
    debugPrint();

    return 0;
}

对比

总结

静态链表：适用于内存受限环境，无需动态内存管理，但灵活性差。
动态链表：灵活但需处理内存分配，可能产生碎片。
双向链表：支持双向遍历，适合频繁前后访问的场景。
循环链表：尾节点连回头节点，适合循环访问需求。

The end…