数据结构单链表合并

单链表合并是指将两个单链表合并成一个单链表。具体实现方法如下：

1. 首先判断两个链表是否为空，若其中一个为空，则直接返回另一个链表。

2. 定义一个新的链表头节点，用于存储合并后的链表。

3. 定义两个指针分别指向两个链表的头节点，比较两个节点的值的大小，将较小的节点插入到新链表中，并将指针指向较小节点的下一个节点。

4. 重复步骤3，直到其中一个链表为空。

5. 将另一个链表剩余的节点插入到新链表中。

6. 返回新链表的头节点。

相关问题

数据结构单链表通讯录

### 回答1：
好的，下面是一个简单的单链表通讯录的数据结构：

struct Contact {
    char name[50];
    char phone[20];
    char email[50];
    struct Contact* next;
};

typedef struct Contact* ContactPtr;

上面的结构体定义了一个通讯录中联系人的信息，包括姓名、电话和电子邮件地址。每个联系人都有一个指向下一个联系人的指针。使用这个结构体，我们可以定义一个单链表的通讯录。

下面是一个简单的实现示例，包括添加联系人、查找联系人和删除联系人等基本操作：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct Contact {
    char name[50];
    char phone[20];
    char email[50];
    struct Contact* next;
};

typedef struct Contact* ContactPtr;

// 初始化通讯录
ContactPtr initContact() {
    ContactPtr head = (ContactPtr)malloc(sizeof(struct Contact));
    head->next = NULL;
    return head;
}

// 添加联系人
void addContact(ContactPtr head, char name[], char phone[], char email[]) {
    ContactPtr newContact = (ContactPtr)malloc(sizeof(struct Contact));
    strcpy(newContact->name, name);
    strcpy(newContact->phone, phone);
    strcpy(newContact->email, email);
    newContact->next = NULL;

    ContactPtr current = head;
    while (current->next != NULL) {
        current = current->next;
    }
    current->next = newContact;

    printf("联系人 %s 添加成功！\n", name);
}

// 查找联系人
void findContact(ContactPtr head, char name[]) {
    ContactPtr current = head->next;
    while (current != NULL) {
        if (strcmp(current->name, name) == 0) {
            printf("%s 的电话号码是：%s，电子邮件地址是：%s\n", current->name, current->phone, current->email);
            return;
        }
        current = current->next;
    }

    printf("未找到联系人 %s！\n", name);
}

// 删除联系人
void deleteContact(ContactPtr head, char name[]) {
    ContactPtr current = head;
    while (current->next != NULL) {
        if (strcmp(current->next->name, name) == 0) {
            ContactPtr temp = current->next;
            current->next = temp->next;
            free(temp);
            printf("联系人 %s 删除成功！\n", name);
            return;
        }
        current = current->next;
    }

    printf("未找到联系人 %s！\n", name);
}

// 打印所有联系人
void printContacts(ContactPtr head) {
    if (head->next == NULL) {
        printf("通讯录为空！\n");
        return;
    }

    ContactPtr current = head->next;
    while (current != NULL) {
        printf("%s 的电话号码是：%s，电子邮件地址是：%s\n", current->name, current->phone, current->email);
        current = current->next;
    }
}

int main() {
    ContactPtr head = initContact();

    addContact(head, "张三", "123456789", "zhangsan@example.com");
    addContact(head, "李四", "987654321", "lisi@example.com");
    addContact(head, "王五", "234567890", "wangwu@example.com");

    printContacts(head);

    findContact(head, "张三");
    findContact(head, "赵六");

    deleteContact(head, "李四");

    printContacts(head);

    return 0;
}

上面的代码实现了一个简单的单链表通讯录，包括添加联系人、查找联系人和删除联系人等基本操作。

### 回答2：
单链表通讯录是一种基于数据结构的通讯录实现方式。通讯录中的每个联系人都被封装为一个节点，节点内包含联系人的信息和一个指向下一个节点的指针。该链表的头节点指向第一个联系人，最后一个联系人的节点指针为空。

单链表通讯录的优点是插入和删除联系人的操作高效。当需要插入一个新的联系人时，只需要修改指针的指向即可，无需移动其他节点。同样，删除联系人时也只需修改指针指向，不需要进行大量的数据迁移。这样可以大大提高操作的效率。

然而，单链表通讯录的缺点是查找联系人的效率相对较低。由于只能按顺序查找，当查找的联系人位于链表的末尾时，需要遍历整个链表寻找，时间复杂度较高。为了解决这个问题，可以使用更高效的数据结构，如哈希表来实现通讯录。

除了基本的插入、删除和查找操作，单链表通讯录还可以进行其他一些常见的操作，如修改联系人信息、排序联系人。修改联系人信息时，可以根据给定的姓名或其他关键字，遍历链表找到指定联系人并修改其信息。排序联系人时，可以使用冒泡排序等算法进行排序，将链表中的联系人按照一定的规则排序。

总的来说，单链表通讯录是一种简单而高效的通讯录实现方式。它具有插入、删除操作高效的优点，但查找效率相对较低。可以根据实际需求选择合适的数据结构来实现通讯录。

### 回答3：
单链表通讯录是一种常见的数据结构，用于存储和管理联系人信息。通讯录中的每个联系人被表示为一个节点，节点包含姓名、电话号码等信息，并且有一个指向下一个节点的指针。

单链表通讯录的优点是插入、删除和查找操作都很高效。在插入操作时，只需将新的联系人节点插入到链表中，并更新相应的指针，即可完成插入操作。在删除操作时，只需修改相应节点的指针，即可将该联系人节点从链表中删除。在查找操作时，只需从头节点开始，依次遍历每个节点，直到找到目标联系人节点为止。

另一个优点是单链表通讯录能够动态地存储联系人信息。链表的长度可以根据需要进行动态调整，不需要预先分配固定的内存空间。这使得单链表通讯录更加灵活和节省内存空间。

然而，单链表通讯录也有一些缺点。首先，查询某个特定联系人节点的效率较低，需要遍历整个链表，尤其在链表较长时，效率较低。其次，在内存分配上可能存在空间浪费的问题，因为每个节点的指针需要占用额外的内存空间。

综上所述，单链表通讯录是一种高效、灵活的数据结构，适合用于存储和管理通讯录信息。但在应用中需要根据具体需求权衡其优缺点，选择合适的数据结构来实现通讯录功能。

数据结构单链表删除

单链表的删除操作可以分为两种情况：删除头节点和删除非头节点。

1. 删除头节点：
首先，将头节点的下一个节点作为新的头节点，然后释放原来的头节点即可完成删除操作。

2. 删除非头节点：
首先，找到要删除节点的前一个节点，将其指针指向要删除节点的下一个节点，然后释放要删除的节点即可完成删除操作。

以下是两种情况的示例代码：

1. 删除头节点：

class Node:
    def __init__(self, data=None):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def delete_head(self):
        if self.head is None:
            return
        self.head = self.head.next

# 创建链表
linked_list = LinkedList()
# 添加节点
node1 = Node(1)
node2 = Node(2)
node3 = Node(3)
linked_list.head = node1
node1.next = node2
node2.next = node3

# 删除头节点
linked_list.delete_head()

2. 删除非头节点：

class Node:
    def __init__(self, data=None):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def delete_node(self, key):
        if self.head is None:
            return
        curr = self.head
        prev = None
        while curr:
            if curr.data == key:
                break
            prev = curr
            curr = curr.next
        if curr is None:
            return
        prev.next = curr.next

# 创建链表
linked_list = LinkedList()
# 添加节点
node1 = Node(1)
node2 = Node(2)
node3 = Node(3)
linked_list.head = node1
node1.next = node2
node2.next = node3

# 删除节点值为2的节点
linked_list.delete_node(2)