写出将两个有序链表合并的C++代码

好的，以下是将两个有序链表合并的C++代码，使用了递归的方法：

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 == NULL) return l2;
        if(l2 == NULL) return l1;
        
        ListNode* res = NULL;
        if(l1->val <= l2->val) {
            res = l1;
            res->next = mergeTwoLists(l1->next, l2);
        } else {
            res = l2;
            res->next = mergeTwoLists(l1, l2->next);
        }
        return res;
    }
};

其中，`ListNode` 是链表节点的定义。我们首先判断两个链表是否为空，如果有一个为空，直接返回另一个链表即可。如果两个链表都不为空，则比较两个链表头节点的值，将较小的节点作为结果链表的头节点，并递归地将其余节点合并到结果链表中。最后返回结果链表的头节点即可。

相关问题

用c++代码完整写出实现终端定义两个链表的长度，分别输入数据，并存储至链表中(默认两个链表为非递减顺序输入)。!实现三个功能:1.将两个有序链表合并成一个新的有序链表!允许重复数据;2.要求合并后的有序链表无重复数据;3.要求合并后的链表为非递增的有序链表的代码

为了帮助您理解如何用 C++ 实现这个功能，我会提供一段完整的代码示例，首先定义链表节点结构，然后创建链表并合并它们。请注意，这里我假设已经有一个简单的链表节点 `Node` 类型定义，包含 `int data` 和 `Node* next` 成员。

#include <iostream>
using namespace std;

// 定义链表节点
struct Node {
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

// 合并两个有序链表函数，处理重复
Node* mergeWithDuplicates(Node* list1, Node* list2) {
    if (!list1) return list2;
    if (!list2) return list1;

    // 如果 list1 的元素小于 list2，则添加到结果列表
    if (list1->data <= list2->data) {
        list1->next = mergeWithDuplicates(list1->next, list2);
        return list1;
    } else {
        list2->next = mergeWithDuplicates(list1, list2->next);
        return list2;
    }
}

// 合并两个有序链表函数，去除重复
Node* mergeWithoutDuplicates(Node* list1, Node* list2) {
    if (!list1 || !list2 || list1->data > list2->data) {
        return list1 ? list1 : list2;
    }

    Node* head = nullptr, *prev = nullptr;
    while (list1 && list2) {
        if (list1->data <= list2->data) {
            if (!head || list1->data < prev->data) {  // 如果新元素最小或为空链表
                head = list1;
                if (prev) prev->next = list1;
            }
            list1 = list1->next;
        } else {
            if (!head || list2->data < prev->data) {  // 同理处理 list2
                head = list2;
                if (prev) prev->next = list2;
            }
            list2 = list2->next;
        }
        prev = head;
    }
    // 添加剩余链表
    prev->next = list1 ? list1 : list2;
    return head;
}

// 函数用于计算链表长度
size_t getLength(Node* list) {
    size_t length = 0;
    while (list) {
        length++;
        list = list->next;
    }
    return length;
}

int main() {
    // 输入链表元素并构建链表
    cout << "请输入链表1的元素 (以空结束): ";
    Node* list1 = nullptr;
    int input1;
    while ((input1 = getchar()) != EOF && input1 != '\n') {
        list1 = new Node(input1);
        if (!list1->next) break;
        list1->next->data = input1;
    }

    cout << "请输入链表2的元素 (以空结束): ";
    Node* list2 = nullptr;
    int input2;
    while ((input2 = getchar()) != EOF && input2 != '\n') {
        list2 = new Node(input2);
        if (!list2->next) break;
        list2->next->data = input2;
    }

    // 合并链表并打印长度
    Node* mergedList;
    mergedList = mergeWithoutDuplicates(list1, list2);  // 选择去重版本
    cout << "合并后链表的长度: " << getLength(mergedList) << endl;

    // 打印合并后的链表
    while (mergedList) {
        cout << mergedList->data << " ";
        mergedList = mergedList->next;
    }
    cout << endl;

    return 0;
}

C++ 合并两个有序链表,并写出主函数

在C++中，合并两个已经排序的链表可以采用递归或者迭代的方式来实现。这里我们提供一个简单的迭代方法示例：

// 链表节点定义
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    // 定义一个新的头结点作为合并后的结果
    ListNode* head = nullptr;
    // 初始化当前指针
    ListNode* cur = head;

    // 当两个链表都不为空
    while (l1 && l2) {
        // 如果l1的值小于l2的值，将l1的元素添加到结果链表中，并移动l1
        if (l1->val < l2->val) {
            cur->next = l1;
            l1 = l1->next;
        }
        // 否则，将l2的元素添加
        else {
            cur->next = l2;
            l2 = l2->next;
        }
        // 移动当前指针
        cur = cur->next;
    }

    // 将剩余的链表添加到结果中（如果有的话）
    if (l1) {
        cur->next = l1;
    } else {
        cur->next = l2;
    }

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

int main() {
    // 创建两个示例链表
    ListNode* list1 = new ListNode(1);
    list1->next = new ListNode(2);
    list1->next->next = new ListNode(4);

    ListNode* list2 = new ListNode(1);
    list2->next = new ListNode(3);
    list2->next->next = new ListNode(4);  // 注意这里的4比list1里的大

    // 合并两个链表
    ListNode* mergedList = mergeTwoLists(list1, list2);

    // 输出合并后的链表（这里仅做演示，实际应用需添加适当输出）
    while (mergedList != nullptr) {
        std::cout << mergedList->val << " ";
        mergedList = mergedList->next;
    }

    // 手动释放内存
    delete mergedList;
    return 0;
}

在这个`main()`函数里，首先创建了两个已排序的链表，然后调用`mergeTwoLists`函数合并它们，最后遍历打印出合并后的链表。