C语言链式存储结构和顺序存储结构

链式存储结构和顺序存储结构是两种常见的数据存储方式，用于在计算机程序中组织和管理数据。

1. 链式存储结构：
链式存储结构使用节点之间的指针关系来存储数据。每个节点包含数据和指向下一个节点的指针。链式存储结构具有以下特点：
- 内存中的节点可以分散存储，不要求连续的内存空间。
- 可以动态地添加、删除节点，不受存储空间大小限制。
- 插入和删除节点的时间复杂度为O(1)。
- 随机访问节点的时间复杂度为O(n)，因为需要从头节点开始逐个遍历，直到找到目标节点。

链式存储结构常用于需要频繁插入和删除操作的场景，例如链表、树和图等数据结构。

链式存储结构的缺点是访问节点时需要遍历链表，效率相对较低。

2. 顺序存储结构：
顺序存储结构使用连续的内存空间来存储数据元素，数据在内存中按照逻辑顺序依次存放。顺序存储结构具有以下特点：
- 数据元素在内存中占据连续的地址空间。
- 随机访问节点的时间复杂度为O(1)，可以通过下标直接访问。
- 插入和删除节点的时间复杂度为O(n)，因为需要移动其他元素的位置。

顺序存储结构常用于需要频繁访问和修改元素的场景，例如数组和矩阵等数据结构。

顺序存储结构的优点是访问元素的效率较高，但是插入和删除元素时需要移动其他元素，可能导致性能下降。

适用情况：

链式存储结构：

1. 需要频繁地进行插入和删除操作：链式存储结构可以通过改变指针的指向来高效地插入和删除元素，不需要移动其他元素，因此适合频繁执行插入和删除操作的场景。

2. 数据量动态变化：链式存储结构可以根据需要动态地分配和释放内存，适合处理数据量不确定或动态增长的情况。

3. 存储空间不连续：链式存储结构通过指针相连，可以克服顺序存储结构需要连续的存储空间的限制。

顺序存储结构：

1. 随机访问和索引操作频繁：顺序存储结构使用数组来存储数据，可以通过索引直接访问元素，因此适合需要频繁进行随机访问和索引操作的场景。

2. 存储空间要求相对较小：顺序存储结构在存储上更加紧凑，不需要额外的指针空间，适合存储空间要求相对较小的情况。

3. 数据量固定不变或者变化较小：顺序存储结构需要在存储时就确定存储空间大小，对于数据量固定不变或变化较小的情况，可以更好地利用存储空间。

参考代码：

链式存储：

// 链式存储示例代码
#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构体
typedef struct Node {
    int data;           // 节点数据
    struct Node* next;  // 指向下一个节点的指针
} Node;

// 创建新节点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));  // 分配内存
    if (newNode == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    newNode->data = data;  // 设置节点数据
    newNode->next = NULL;  // 将节点的next指针初始化为NULL
    return newNode;
}

// 在链表末尾插入节点
void appendNode(Node** head, int data) {
    Node* newNode = createNode(data);  // 创建新节点
    if (*head == NULL) {
        *head = newNode;  // 如果链表为空，则将头指针指向新节点
    } else {
        Node* current = *head;
        while (current->next != NULL) {  // 找到链表的末尾节点
            current = current->next;
        }
        current->next = newNode;  // 在末尾节点的next指针处插入新节点
    }
}

// 打印链表
void printLinkedList(Node* head) {
    Node* current = head;
    while (current != NULL) {  // 遍历链表
        printf("%d ", current->data);  // 打印当前节点的数据
        current = current->next;  // 移动到下一个节点
    }
    printf("\n");
}

int main() {
    Node* head = NULL;  // 链表的头指针
    appendNode(&head, 1);  // 在链表末尾插入节点
    appendNode(&head, 2);
    appendNode(&head, 3);
    printf("链式存储：\n");
    printLinkedList(head);  // 打印链表

    return 0;
}

顺序存储：

// 顺序存储示例代码
#include <stdio.h>

#define MAX_SIZE 100  // 数组的最大大小

// 初始化数组
void initArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        arr[i] = 0;  // 将数组的元素初始化为0
    }
}

// 在数组末尾插入元素
void appendArray(int arr[], int* size, int data) {
    if (*size < MAX_SIZE) {  // 判断数组是否已满
        arr[*size] = data;  // 将元素插入到数组末尾
        (*size)++;  // 数组大小加1
    } else {
        printf("数组已满，无法插入\n");
    }
}

// 打印数组
void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);  // 打印数组元素
    }
    printf("\n");
}

int main() {
    int arr[MAX_SIZE];  // 数组
    int size = 0;  // 数组的大小
    initArray(arr, MAX_SIZE);  // 初始化数组
    appendArray(arr, &size, 1);  // 在数组末尾插入元素
    appendArray(arr, &size, 2);
    appendArray(arr, &size, 3);
    printf("顺序存储：\n");
    printArray(arr, size);  // 打印数组

    return 0;
}