C语言中链表怎么实现C语言链表操作的基本步骤和示例

#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) {
        perror("Failed to allocate memory");
        exit(EXIT_FAILURE);
    }
    newNode->data = data;
    newNode->next = NULL; // 新节点是尾节点，next指向NULL
    return newNode;
}

// 在链表头部插入节点
void insertAtBeginning(Node** head, int data) {
    Node* newNode = createNode(data);
    newNode->next = *head; // 新节点的next指向原来的头节点
    *head = newNode;      // 更新头节点为新节点
}

// 在链表尾部插入节点
void insertAtEnd(Node** head, int data) {
    Node* newNode = createNode(data);
    if (*head == NULL) { // 如果链表为空
        *head = newNode;   // 新节点成为头节点
        return;
    }
    Node* current = *head;
    while (current->next != NULL) { // 找到尾节点
        current = current->next;
    }
    current->next = newNode; // 尾节点的next指向新节点
}

// 在指定位置插入节点（pos从0开始计数）
void insertAtPosition(Node** head, int data, int pos) {
    if (pos < 0) {
        printf("Invalid position.\n");
        return;
    }
    if (pos == 0) { // 在头部插入，等同于insertAtBeginning
        insertAtBeginning(head, data);
        return;
    }

    Node* newNode = createNode(data);
    Node* current = *head;
    Node* previous = NULL;
    int i = 0;

    while (current != NULL && i < pos) {
        previous = current;
        current = current->next;
        i++;
    }

    if (i != pos) { // 位置超出链表长度
        printf("Position out of range.\n");
        free(newNode); // 释放已分配的内存
        return;
    }

    newNode->next = current;
    previous->next = newNode;
}


// 删除指定数据的节点（删除第一个匹配的节点）
void deleteNode(Node** head, int data) {
    Node* current = *head;
    Node* previous = NULL;

    // 如果链表为空
    if (*head == NULL) {
        return;
    }

    // 如果头节点就是要删除的节点
    if (current->data == data) {
        *head = current->next;
        free(current);
        return;
    }

    // 遍历链表找到要删除的节点
    while (current != NULL && current->data != data) {
        previous = current;
        current = current->next;
    }

    // 如果没找到要删除的节点
    if (current == NULL) {
        return;
    }

    // 删除节点
    previous->next = current->next;
    free(current);
}


// 遍历链表
void printList(Node* head) {
    Node* current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

// 释放链表内存
void freeList(Node** head) {
    Node* current = *head;
    Node* nextNode;
    while (current != NULL) {
        nextNode = current->next;
        free(current);
        current = nextNode;
    }
    *head = NULL; // 将头指针置空
}


int main() {
    Node* head = NULL; // 初始化头指针

    insertAtEnd(&head, 1);
    insertAtEnd(&head, 2);
    insertAtEnd(&head, 3);
    printf("链表内容: ");
    printList(head); // 输出：1 2 3

    insertAtBeginning(&head, 0);
    printf("头部插入后: ");
    printList(head); // 输出：0 1 2 3

    insertAtPosition(&head, 5, 2);
    printf("指定位置插入后: ");
    printList(head); // 输出：0 1 5 2 3

    deleteNode(&head, 2);
    printf("删除节点后: ");
    printList(head); // 输出：0 1 5 3

    freeList(&head);
    printf("链表释放后: ");
    printList(head); // 输出：（空）

    return 0;
}

#include <stdbool.h> // 引入 bool 类型

bool hasCycle(Node* head) {
    if (head == NULL || head->next == NULL) {
        return false; // 空链表或只有一个节点，不可能有环
    }

    Node* slow = head;
    Node* fast = head;

    while (fast != NULL && fast->next != NULL) {
        slow = slow->next;       // 慢指针走一步
        fast = fast->next->next;  // 快指针走两步

        if (slow == fast) {
            return true; // 快慢指针相遇，说明有环
        }
    }

    return false; // 快指针到达链表末尾，说明没有环
}

Node* reverseList(Node* head) {
    Node* prev = NULL;
    Node* current = head;
    Node* next = NULL;

    while (current != NULL) {
        next = current->next; // 保存下一个节点
        current->next = prev; // 当前节点的next指向前一个节点

        prev = current;       // 前一个节点更新为当前节点
        current = next;       // 当前节点更新为下一个节点
    }

    return prev; // prev现在指向新的头节点
}

Node* reverseListRecursive(Node* head) {
    if (head == NULL || head->next == NULL) {
        return head; // 空链表或只有一个节点，直接返回
    }

    Node* newHead = reverseListRecursive(head->next); // 递归反转后面的链表
    head->next->next = head;                           // 将当前节点的下一个节点的next指向当前节点
    head->next = NULL;                                  // 当前节点的next置为NULL

    return newHead; // 返回新的头节点
}