Description

假定两个单链表是递增有序，定义并实现以下函数，完成两个单链表的合并，继续保持递增有序

int LL_merge(ListNode *La, ListNode *Lb)

Input

第1行先输入n表示有n个数据，接着输入n个数据

第2行先输入m表示有M个数据，接着输入m个数据

Output

输出合并后的单链表数据，数据之间用空格隔开

Sample

 

AC代码：

//请勿直接复制粘贴，答案仅供参考
#include<iostream>
using namespace std;
#define ok 0
#define error -1

// 链表结点定义
class ListNode
{
public:
    int data;
    ListNode* next;
    ListNode() { next = NULL; }
};
// 带头结点的单链表类定义
class LinkList
{
public:
    ListNode* head;
    int len;
    // 操作定义
    LinkList();
    void LL_set(int i) {
        len = i;
        int item;
        ListNode* p;
        p = head;
        for (int j = 0; j < i; j++) {
            cin >> item;
            ListNode* s = new ListNode;
            s->data = item;
            s->next = p->next;
            p->next = s;
            p = s;
        }
    }; // 初始化链表
    void LL_merge(LinkList La, LinkList Lb) { 
        ListNode* p1 = La.head->next;
        ListNode* p2 = Lb.head->next;
        ListNode* p3 = head;
        while (p1 && p2) {
            if (p1->data > p2->data) {
                p3->next = p2;
                p3 = p2;
                p2 = p2->next;
            }
            else {
                p3->next = p1;
                p3 = p1;
                p1 = p1->next;
            }
        }
        p3->next = p1 ? p1 : p2;
        LL_display();
    };
    void LL_display();              // 输出单链表的内容
};
LinkList::LinkList()
{
    head = new ListNode();
    len = 0;
}
void LinkList::LL_display()
{
    ListNode* p;
    p = head->next;
    while (p)
    {
        cout << p->data << ' ';
        p = p->next;
    }
    cout << endl;
}

int main() {
    LinkList *a = new LinkList;
    LinkList *b = new LinkList;
    int t1, t2;
    cin >> t1;
    a->LL_set(t1);
    cin >> t2;
    b->LL_set(t2);
    ListNode* p1;
    ListNode* p2;
    p1 = a->head;
    p2 = b->head;
    LinkList* c = new LinkList;
    c->LL_merge(*a,*b);
}