单向链表，双向链表的操作

单向链表

1. 查找操作

在链表中查找某个值。

struct Node* search(int key) {
    struct Node* temp = head;
    while (temp != NULL) {
        if (temp->data == key) {
            return temp;
        }
        temp = temp->next;
    }
    return NULL;
}

2. 反转链表

将链表反转，使每个节点的指针指向前一个节点。

void reverse() {
    struct Node* prev = NULL;
    struct Node* current = head;
    struct Node* next = NULL;
    
    while (current != NULL) {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    head = prev;
}

双向链表

双向链表是一种链式数据结构，每个节点包含三个部分：数据域、指向前一个节点的指针（prev）、以及指向后一个节点的指针（next）。与单向链表相比，双向链表的优点在于可以在 O(1) 时间内访问前一个节点。

1. 创建链表

初始化一个空的双向链表，通常用一个指向第一个节点的头指针。

struct Node {
    int data;
    struct Node* prev;
    struct Node* next;
};

struct Node* head = NULL; // 初始化头指针为空

2. 插入操作

双向链表的插入操作可以在头部、尾部或中间位置进行。

a. 头插法

将新节点插入到链表的头部。

void insertAtHead(int value) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->prev = NULL;
    newNode->next = head;

    if (head != NULL) {
        head->prev = newNode;
    }
    head = newNode;
}

b. 尾插法

将新节点插入到链表的尾部。

void insertAtTail(int value) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->next = NULL;

    if (head == NULL) {
        newNode->prev = NULL;
        head = newNode;
        return;
    }

    struct Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
    newNode->prev = temp;
}

c. 中间插入

在指定位置之后插入新节点。

void insertAfter(struct Node* prevNode, int value) {
    if (prevNode == NULL) {
        printf("Previous node cannot be NULL");
        return;
    }

    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->next = prevNode->next;
    newNode->prev = prevNode;

    if (prevNode->next != NULL) {
        prevNode->next->prev = newNode;
    }
    prevNode->next = newNode;
}

3. 删除操作

双向链表的删除操作可以是删除头节点、尾节点或任意节点。

a. 删除头节点

void deleteHead() {
    if (head == NULL) {
        return;
    }

    struct Node* temp = head;
    head = head->next;

    if (head != NULL) {
        head->prev = NULL;
    }

    free(temp);
}

b. 删除尾节点

void deleteTail() {
    if (head == NULL) {
        return;
    }

    struct Node* temp = head;

    while (temp->next != NULL) {
        temp = temp->next;
    }

    if (temp->prev != NULL) {
        temp->prev->next = NULL;
    } else {
        head = NULL; // 如果只有一个节点
    }

    free(temp);
}

c. 删除指定节点

删除链表中的某个指定节点。

void deleteNode(struct Node* delNode) {
    if (head == NULL || delNode == NULL) {
        return;
    }

    if (head == delNode) {
        head = delNode->next;
    }

    if (delNode->next != NULL) {
        delNode->next->prev = delNode->prev;
    }

    if (delNode->prev != NULL) {
        delNode->prev->next = delNode->next;
    }

    free(delNode);
}

4. 查找操作

在链表中查找某个值。

struct Node* search(int key) {
    struct Node* temp = head;
    while (temp != NULL) {
        if (temp->data == key) {
            return temp;
        }
        temp = temp->next;
    }
    return NULL;
}

 

5. 打印链表

遍历并打印链表中的所有节点，从头到尾和从尾到头都可以进行。

a. 从头到尾打印

void printList() {
    struct Node* temp = head;
    while (temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");
}

b. 从尾到头打印

void printListReverse() {
    struct Node* temp = head;
    if (temp == NULL) return;

    while (temp->next != NULL) {
        temp = temp->next;
    }

    while (temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->prev;
    }
    printf("NULL\n");
}

6. 反转链表

将链表反转，使每个节点的 next 和 prev 指针互换。

void reverse() {
    struct Node* temp = NULL;
    struct Node* current = head;

    while (current != NULL) {
        temp = current->prev;
        current->prev = current->next;
        current->next = temp;
        current = current->prev;
    }

    if (temp != NULL) {
        head = temp->prev;
    }
}