编写程序实现将两个带头结点的单链表，合并为一个带头结点的单链表，简单代码

以下是合并两个带头结点的单链表的简单代码实现：

def merge_lists(head1, head2):
    p1 = head1.next
    p2 = head2.next
    new_head = ListNode(-1)
    p = new_head
    while p1 and p2:
        if p1.val < p2.val:
            p.next = p1
            p1 = p1.next
        else:
            p.next = p2
            p2 = p2.next
        p = p.next
    p.next = p1 if p1 else p2
    return new_head

上述代码中，我们将两个链表的头结点传入函数 `merge_lists()`，并创建一个新的带头结点的链表 `new_head`。然后，我们使用指针 `p1` 和 `p2` 分别指向两个链表的第一个节点。然后，我们创建一个指针 `p`，它指向新链表的头结点。

在循环中，我们比较 `p1` 和 `p2` 的值，将较小值的节点接到新链表的尾部，并将指针 `p1` 或 `p2` 向后移动一位，直到两个指针中至少有一个为空。

最后，我们将剩下的节点接到新链表的尾部，返回新链表的头结点 `new_head`。

相关问题

编写程序实现将两个带头结点的单链表，合并为一个带头结点的单链表，C++简单代码

以下是C++简单代码实现：

#include <iostream>

using namespace std;

// 定义链表节点的结构体
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

// 合并两个带头结点的单链表
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    ListNode *head = new ListNode(0);
    ListNode *cur = head;
    while (l1 && l2) {
        if (l1->val < l2->val) {
            cur->next = l1;
            l1 = l1->next;
        } else {
            cur->next = l2;
            l2 = l2->next;
        }
        cur = cur->next;
    }
    cur->next = l1 ? l1 : l2;
    return head->next;
}

// 测试
int main() {
    // 初始化链表1
    ListNode *l1 = new ListNode(0);
    ListNode *p1 = l1;
    for (int i = 1; i <= 5; ++i) {
        ListNode *node = new ListNode(i);
        p1->next = node;
        p1 = p1->next;
    }

    // 初始化链表2
    ListNode *l2 = new ListNode(0);
    ListNode *p2 = l2;
    for (int i = 6; i <= 10; ++i) {
        ListNode *node = new ListNode(i);
        p2->next = node;
        p2 = p2->next;
    }

    // 合并两个链表
    ListNode *head = mergeTwoLists(l1->next, l2->next);

    // 输出结果
    while (head) {
        cout << head->val << " ";
        head = head->next;
    }
    return 0;
}

输出结果为：1 2 3 4 5 6 7 8 9 10

编写程序实现将两个带头结点的单链表，合并为一个带头结点的单链表，使用C++编写一个简单代码

下面是一个简单的C++代码实现：

#include <iostream>

using namespace std;

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    ListNode *dummy = new ListNode(0);
    ListNode *cur = dummy;
    while (l1 && l2) {
        if (l1->val <= l2->val) {
            cur->next = l1;
            l1 = l1->next;
        } else {
            cur->next = l2;
            l2 = l2->next;
        }
        cur = cur->next;
    }
    cur->next = l1 ? l1 : l2;
    return dummy->next;
}

int main() {
    // 构造两个链表
    ListNode *l1 = new ListNode(1);
    l1->next = new ListNode(3);
    l1->next->next = new ListNode(5);

    ListNode *l2 = new ListNode(2);
    l2->next = new ListNode(4);
    l2->next->next = new ListNode(6);

    // 合并两个链表
    ListNode *merged = mergeTwoLists(l1, l2);

    // 输出合并后的链表
    while (merged) {
        cout << merged->val << " ";
        merged = merged->next;
    }
    cout << endl;

    return 0;
}

该程序首先定义了一个结构体`ListNode`表示链表中的一个节点，并且定义了一个函数`mergeTwoLists`用于将两个带头结点的单链表合并为一个带头结点的单链表。程序中的主要逻辑是利用两个指针`l1`和`l2`分别指向两个链表的头节点，然后不断比较`l1`和`l2`节点的值，将较小的节点插入到新链表中，直到其中一个链表为空。最后，将剩余的链表直接接到新链表的末尾即可。注意，程序中还定义了一个虚拟头节点`dummy`，这是为了方便处理链表的边界情况。