c语言如何建单链表

C语言如何建单链表

在C语言中，构建单链表的核心步骤包括：定义节点结构、创建新节点、在链表中插入节点、删除节点、遍历链表。接下来，我们将详细介绍如何实现这些步骤，并通过具体代码示例来展示。

一、定义节点结构

在C语言中，我们使用结构体（struct）来定义单链表的节点。每个节点包含两个部分：一个是存储数据的部分，另一个是指向下一个节点的指针。

#include <stdio.h>
#include <stdlib.h>
// 定义节点结构体
struct Node {
    int data;
    struct Node* next;
};

二、创建新节点

创建新节点的函数通常包括分配内存和初始化节点的两个步骤。我们使用malloc函数来分配内存，并将数据赋值给节点的data成员。

// 创建新节点
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    if (!newNode) {
        printf("Memory allocation errorn");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

三、在链表中插入节点

根据需求，我们可以在链表的头部、尾部或中间插入节点。这里我们主要介绍在头部和尾部插入节点的方法。

1、在头部插入节点

在头部插入节点非常简单，只需要将新节点的next指针指向当前的头节点，并将头指针指向新节点即可。

// 在头部插入节点
void insertAtHead(struct Node head, int data) {
    struct Node* newNode = createNode(data);
    newNode->next = *head;
    *head = newNode;
}

2、在尾部插入节点

在尾部插入节点需要遍历链表，找到最后一个节点，并将其next指针指向新节点。

// 在尾部插入节点
void insertAtTail(struct Node head, int data) {
    struct Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    struct Node* temp = *head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
}

四、删除节点

删除节点可以分为删除头节点、删除中间节点和删除尾节点。这里我们主要介绍删除特定值的节点的方法。

// 删除特定值的节点
void deleteNode(struct Node head, int key) {
    struct Node* temp = *head;
    struct Node* prev = NULL;
    // 如果头节点就是要删除的节点
    if (temp != NULL && temp->data == key) {
        *head = temp->next;
        free(temp);
        return;
    }
    // 搜索要删除的节点
    while (temp != NULL && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }
    // 如果没有找到要删除的节点
    if (temp == NULL) return;
    // 解除节点的连接
    prev->next = temp->next;
    free(temp);
}

五、遍历链表

遍历链表是指从头节点开始，依次访问每个节点，直到链表的末尾。我们可以在遍历过程中进行各种操作，比如打印每个节点的数据。

// 遍历链表并打印每个节点的数据
void printList(struct Node* head) {
    struct Node* temp = head;
    while (temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("NULLn");
}

六、综合示例

最后，我们将上述所有的操作结合起来，构建一个完整的示例程序。

#include <stdio.h>
#include <stdlib.h>
// 定义节点结构体
struct Node {
    int data;
    struct Node* next;
};
// 创建新节点
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    if (!newNode) {
        printf("Memory allocation errorn");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}
// 在头部插入节点
void insertAtHead(struct Node head, int data) {
    struct Node* newNode = createNode(data);
    newNode->next = *head;
    *head = newNode;
}
// 在尾部插入节点
void insertAtTail(struct Node head, int data) {
    struct Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    struct Node* temp = *head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
}
// 删除特定值的节点
void deleteNode(struct Node head, int key) {
    struct Node* temp = *head;
    struct Node* prev = NULL;
    // 如果头节点就是要删除的节点
    if (temp != NULL && temp->data == key) {
        *head = temp->next;
        free(temp);
        return;
    }
    // 搜索要删除的节点
    while (temp != NULL && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }
    // 如果没有找到要删除的节点
    if (temp == NULL) return;
    // 解除节点的连接
    prev->next = temp->next;
    free(temp);
}
// 遍历链表并打印每个节点的数据
void printList(struct Node* head) {
    struct Node* temp = head;
    while (temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("NULLn");
}
// 主函数
int main() {
    struct Node* head = NULL;
    insertAtHead(&head, 1);
    insertAtHead(&head, 2);
    insertAtHead(&head, 3);
    insertAtTail(&head, 4);
    insertAtTail(&head, 5);
    printf("链表内容: ");
    printList(head);
    deleteNode(&head, 3);
    printf("删除值3后的链表内容: ");
    printList(head);
    return 0;
}

通过以上步骤，我们可以创建、插入、删除和遍历单链表。这些操作是构建和操作单链表的基础，也是进行更复杂链表操作的前提。希望这篇文章能对你学习和使用C语言构建单链表有所帮助。

七、链表的应用场景

单链表在很多实际应用中都有广泛的应用，包括但不限于以下几个方面：

1、动态数据存储

单链表的一个主要应用是动态数据存储。与数组不同，链表不需要提前知道数据的数量，可以根据需要动态地增加或减少节点。这使得链表在处理动态数据时非常有用。

2、实现堆栈和队列

链表可以用来实现堆栈和队列数据结构。堆栈是后进先出（LIFO）的数据结构，可以用链表的头部插入和删除节点来实现。队列是先进先出（FIFO）的数据结构，可以用链表的头部插入和尾部删除节点来实现。

3、图的邻接表表示

在图的表示中，邻接表是一种常用的表示方法。每个顶点对应一个链表，链表中的每个节点表示与该顶点相邻的顶点。这种表示方法在处理稀疏图时非常有效。

八、链表的优缺点

1、优点

动态内存分配：链表不需要提前分配固定大小的内存，可以根据需要动态增加或减少节点。
插入和删除操作高效：链表的插入和删除操作只需要修改指针，不需要移动大量数据，时间复杂度为O(1)。
灵活性高：链表可以方便地实现各种复杂的数据结构，如双向链表、循环链表等。

2、缺点

内存消耗较大：链表的每个节点除了存储数据外，还需要存储指向下一个节点的指针，这会增加内存消耗。
访问效率低：链表的随机访问效率较低，需要从头节点开始依次遍历，时间复杂度为O(n)。
容易产生碎片：由于链表节点的内存是动态分配的，频繁的插入和删除操作可能会导致内存碎片，影响程序性能。

九、链表的改进

为了克服单链表的一些缺点，可以对其进行改进，常见的改进方法有以下几种：

1、双向链表

双向链表中的每个节点除了指向下一个节点的指针外，还增加了一个指向前一个节点的指针。这样可以方便地在链表中进行双向遍历，提高访问效率。

// 定义双向链表节点结构体
struct DNode {
    int data;
    struct DNode* prev;
    struct DNode* next;
};

2、循环链表

循环链表是一种特殊的链表，其中最后一个节点的next指针指向头节点，形成一个环。循环链表可以方便地实现一些循环访问的需求。

// 在尾部插入节点（循环链表）
void insertAtTailCircular(struct Node head, int data) {
    struct Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
        newNode->next = *head;
        return;
    }
    struct Node* temp = *head;
    while (temp->next != *head) {
        temp = temp->next;
    }
    temp->next = newNode;
    newNode->next = *head;
}

十、链表操作的复杂度分析

在分析链表操作的时间复杂度时，我们通常关注以下几个方面：

1、插入操作

在头部插入：时间复杂度为O(1)，因为只需要修改头指针即可。
在尾部插入：时间复杂度为O(n)，因为需要遍历链表找到最后一个节点。
在中间插入：时间复杂度为O(n)，因为需要遍历链表找到插入位置。

2、删除操作

删除头节点：时间复杂度为O(1)，因为只需要修改头指针即可。
删除尾节点：时间复杂度为O(n)，因为需要遍历链表找到倒数第二个节点。
删除中间节点：时间复杂度为O(n)，因为需要遍历链表找到删除位置。

3、查找操作

查找特定值的节点：时间复杂度为O(n)，因为需要遍历链表找到目标节点。

通过对链表操作的复杂度分析，我们可以更好地理解链表的性能特点，并在实际应用中合理选择数据结构。

十一、链表的实际应用案例

1、实现LRU缓存

LRU（Least Recently Used）缓存是一种常用的缓存替换策略，可以使用双向链表和哈希表来实现。双向链表用于维护缓存的访问顺序，哈希表用于快速查找缓存中的数据。

#include <stdio.h>
#include <stdlib.h>
#define CAPACITY 3  // 缓存容量
// 定义双向链表节点结构体
struct DNode {
    int key;
    int value;
    struct DNode* prev;
    struct DNode* next;
};
// 定义LRU缓存结构体
struct LRUCache {
    int size;
    int capacity;
    struct DNode* head;
    struct DNode* tail;
    struct DNode* hashTable[CAPACITY];
};
// 创建新节点
struct DNode* createNode(int key, int value) {
    struct DNode* newNode = (struct DNode*)malloc(sizeof(struct DNode));
    newNode->key = key;
    newNode->value = value;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}
// 创建LRU缓存
struct LRUCache* createCache(int capacity) {
    struct LRUCache* cache = (struct LRUCache*)malloc(sizeof(struct LRUCache));
    cache->size = 0;
    cache->capacity = capacity;
    cache->head = NULL;
    cache->tail = NULL;
    for (int i = 0; i < CAPACITY; i++) {
        cache->hashTable[i] = NULL;
    }
    return cache;
}
// 将节点移动到头部
void moveToHead(struct LRUCache* cache, struct DNode* node) {
    if (cache->head == node) return;
    if (node->prev != NULL) {
        node->prev->next = node->next;
    }
    if (node->next != NULL) {
        node->next->prev = node->prev;
    }
    if (cache->tail == node) {
        cache->tail = node->prev;
    }
    node->next = cache->head;
    node->prev = NULL;
    if (cache->head != NULL) {
        cache->head->prev = node;
    }
    cache->head = node;
    if (cache->tail == NULL) {
        cache->tail = node;
    }
}
// 移除尾部节点
void removeTail(struct LRUCache* cache) {
    if (cache->tail == NULL) return;
    struct DNode* temp = cache->tail;
    if (cache->tail->prev != NULL) {
        cache->tail->prev->next = NULL;
    } else {
        cache->head = NULL;
    }
    cache->tail = cache->tail->prev;
    cache->hashTable[temp->key % CAPACITY] = NULL;
    free(temp);
    cache->size--;
}
// 添加数据到缓存
void put(struct LRUCache* cache, int key, int value) {
    int hashIndex = key % CAPACITY;
    struct DNode* node = cache->hashTable[hashIndex];
    if (node == NULL) {
        node = createNode(key, value);
        cache->hashTable[hashIndex] = node;
        if (cache->size == cache->capacity) {
            removeTail(cache);
        }
        cache->size++;
        moveToHead(cache, node);
    } else {
        node->value = value;
        moveToHead(cache, node);
    }
}
// 获取缓存中的数据
int get(struct LRUCache* cache, int key) {
    int hashIndex = key % CAPACITY;
    struct DNode* node = cache->hashTable[hashIndex];
    if (node == NULL) {
        return -1; // 数据不在缓存中
    } else {
        moveToHead(cache, node);
        return node->value;
    }
}
int main() {
    struct LRUCache* cache = createCache(CAPACITY);
    put(cache, 1, 1);
    put(cache, 2, 2);
    put(cache, 3, 3);
    printf("获取键1的值: %dn", get(cache, 1)); // 输出1
    put(cache, 4, 4); // 缓存已满，移除最久未使用的键2
    printf("获取键2的值: %dn", get(cache, 2)); // 输出-1（数据不在缓存中）
    return 0;
}

通过上述代码，我们实现了一个简单的LRU缓存。LRU缓存是一种常用的数据结构，在内存管理、数据库系统等领域有广泛的应用。

十二、总结

通过本文的介绍，我们详细讲解了C语言中如何构建单链表，包括定义节点结构、创建新节点、在链表中插入节点、删除节点、遍历链表等基本操作。同时，我们还探讨了链表的应用场景、优缺点、改进方法以及实际应用案例。希望通过这些内容，能够帮助读者更好地理解和掌握单链表的相关知识，并在实际编程中灵活运用。