【id:23】【20分】C. DS单链表--合并

题目描述

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

int LL_merge(ListNode *La, ListNode *Lb)

输入

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

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

输出

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

样例查看模式

正常显示查看格式

输入样例1 <-复制

输出样例1

语言: 编译选项

主题:

#include<iostream>
using namespace std;
#define ok 0;
#define error -1;

class ListNode
{
public:
    int data;
    ListNode* next;
    ListNode()
    {
        next = NULL;
    }
    ListNode(int i)
    {
        this->data = i;
        next = NULL;//指向下一个的指针都是不知道的
    }
};

class LinkList
{
public:
    ListNode* head;
    //listcode类型的指针
    int len;
    LinkList()
    {
        head = new ListNode();
        len = 0;
        //表示整个链表的长度
    }
    ~LinkList()
    {
        ListNode* p, * q;
        p = head;//定义一个空指针先指向第一个节点的地址
        while (p != NULL)
        {
            q = p;
            //指针q指向指针p
            p = p->next;
            //p往后移一位
            delete q;
            //删除前面那个指针
            //直到删除到p为空指针为止
        }
        len = 0;
        head = NULL;
    }
ListNode* LL_index(int i)
//返回第i个节点的指针，如果不存在则返回NULL
{
    if (i - 1 > len || i <= 0)
    {
        return NULL;
    }
    else
    {
        ListNode* p;
        p = head->next;
        for (int j = 1; j < i; j++)
        {
            p = p->next;
            //指向后一个元素
        }
        return p;
    }
}
int LL_get(int i)
{
    if (i > len || i <= 0)
    {
        return error;
    }
    else
    {
        ListNode* p;
        p = head->next;
        for (int j = 1; j < i; j++)
        {
            p = p->next;
            //指向后一个元素
        }
        return p->data;
    }
}
int LL_insert(int i, int item)
{
    if (i - 1 > len || i <= 0)
    {
        return error;
    }
    else
    {
        ListNode* pre = head, * new1, * after;
        ListNode* p = head->next;
        for (int j = 1; j < i; j++)
        {
            pre = p;
            //要得到转换的前一个位置
            p = p->next;
            //p往后一位
        }
        new1 = new ListNode();
        new1->data = item;
        new1->next = p;
        pre->next = new1;
        len++;
        return ok;
    }
}
int LL_del(int i)
{
    if (i - 1 > len || i <= 0)
    {
        return error;
    }
    else
    {
        //完全可以直接指向后两个，直接跳过后面的一个来实现删除，
        //但是代表删除的元素，将会永远存在，并且无法找回并删除
        ListNode* p, * pre = head, * after;
        p = head->next;
        for (int j = 1; j < i; j++)
        {
            pre = p;
            //同样记录前面一个位置
            p = p->next;
        }
        after = p->next;
        //用after记录后一个位置
        p = NULL;
        pre->next = after;
        len--;
        return ok;
    }
}
void LL_display()
{
    ListNode* p;
    p = head->next;
    while (p)
    {
        cout << p->data << ' ';
        p = p->next;
    }
    cout << endl;
}
int swap(int pa, int pb)  //pa和pb表示两个结点在单链表的位置序号
{
    if (pa<1 || pa>len || pb<1 || pb>len|| pa==pb )
    {
        return error;
    }
    else
    {
        ListNode* prea, * p1, * preb, * p2;
        prea = head;
        preb = head;
        p1 = head->next;
        p2 = head->next;
        for (int i = 1; i < pa; i++)
        {
            prea = p1;
            p1 = p1->next;
            //往后移动一位,得到第一个要交换的位置
        }
        for (int i = 1; i < pb; i++)
        {
            preb = p2;
            p2 = p2->next;
            //往后移动一位,得到第二个要交换的位置
        }
        ListNode* t;
        t = prea->next;
        prea->next = preb->next;
        preb->next = t;
        //交换前躯
        t = prea->next->next;
        prea->next->next = preb->next->next;
        preb->next->next = t;
        //交换后继续
        return ok;
    }
}
};
ListNode* LL_merge(ListNode* La, ListNode* Lb)
{
    ListNode* prehead = new ListNode(-1);
    //指向-1是因为做头指针
    ListNode* prev = prehead;
    while (La != NULL && Lb != NULL)
    {
        if (La->data < Lb->data)
        {
            prev->next = La;
            La = La->next;
            prev = prev->next;
        }
        else
        {
            prev->next = Lb;
            Lb = Lb->next;
            prev = prev->next;
        }
    }
    //最后还有一个没有被合并完
    prev->next = La == NULL ? Lb : La;
    return prehead->next;
}
int main()
{
    LinkList p;
    ListNode* l1, * l2, * l3, * cur;
    l1 = new ListNode(-1);
    l2 = new ListNode(-1);
    int num, lenth;
    cin >> lenth;
    cur = l1;
    for (int i = 0; i < lenth; i++)
    {
        cin >> num;
        cur->next = new ListNode(num);
        cur = cur->next;
    }
    cin >> lenth;
    cur = l2;
    for (int i = 0; i < lenth; i++)
    {
        cin >> num;
        cur->next = new ListNode(num);
        cur = cur->next;
    }
    l3 = LL_merge(l1->next, l2->next);
    while (l3)
    {
        cout << l3->data << " ";
        l3 = l3->next;
    }
    return 0;
}