数据结构-链表的基本操作

双向链表与单链表不同之处在于它的每个节点有两个指针，一个指向前一个节点，一个指向后一个节点。这使得在双向链表中插入和删除节点变得更加灵活。

双向链表的节点结构

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

双向链表节点的插入操作

在双向链表中，插入操作分为三种情况：

1. 在链表头部插入新节点
2. 在链表中间插入新节点
3. 在链表尾部插入新节点

在链表头部插入新节点

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

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

    *head = newNode;
}

在链表中间插入新节点

void insertInMiddle(struct Node* prevNode, int data) {
    if (prevNode == NULL) {
        printf("Previous node cannot be NULL\n");
        return;
    }

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

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

    prevNode->next = newNode;
}

在链表尾部插入新节点

void insertAtEnd(struct Node** head, int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    struct Node* last = *head;

    newNode->data = data;
    newNode->next = NULL;

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

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

    last->next = newNode;
    newNode->prev = last;
}

双向链表节点的删除操作

删除操作也分为三种情况：

1. 删除链表头节点
2. 删除链表中间节点
3. 删除链表尾节点

删除链表头节点

void deleteFromBeginning(struct Node** head) {
    if (*head == NULL) {
        return;
    }

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

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

    free(temp);
}

删除链表中间节点

void deleteFromMiddle(struct Node** head, struct Node* del) {
    if (*head == NULL || del == NULL) {
        return;
    }

    if (*head == del) {
        *head = del->next;
    }

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

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

    free(del);
}

删除链表尾节点

void deleteFromEnd(struct Node** head) {
    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);
}

双向链表的插入和删除操作相对于单链表更加灵活和高效。

在线性表中，合并指的是将两个线性表合并成一个新的线性表。通常涉及到两种数据结构：顺序表和链表。

合并顺序表

在合并两个顺序表时，我们需要将第二个顺序表的元素按顺序添加到第一个顺序表的后面。

void mergeArrays(int arr1[], int n1, int arr2[], int n2, int mergedArr[]) {
    int i, j, k;

    for (i = 0; i < n1; i++) {
        mergedArr[i] = arr1[i];
    }

    for (j = 0, k = n1; j < n2; j++, k++) {
        mergedArr[k] = arr2[j];
    }
}

合并链表

在合并两个链表时，我们需要将第二个链表连接到第一个链表的末尾。这涉及到调整指针的指向以确保链表的正确连接。

单链表合并

struct Node* mergeLinkedLists(struct Node* head1, struct Node* head2) {
    struct Node* temp = head1;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = head2;
    return head1;
}

双向链表合并

void mergeDoublyLinkedLists(struct Node** head1, struct Node** head2) {
    struct Node* temp = *head1;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = *head2;
    (*head2)->prev = temp;
}

合并线性表是一个常见的操作，可以将多个线性表中的元素合并成一个新的线性表，从而实现数据整合和处理。