单链表的合并(c++实现)

场景:

两个非递减单链表合并为一个非递减单链表

例如:{1,3,6,8}和{2,3,7,9,11,13}合并为{1,2,3,3,6,7,8,9,11,13}


代码:

提示:需考虑当一个表满后,将另一个表的剩余结点直接移到新链表。

#include <iostream>

typedef struct LNode{
    int data;
    struct LNode *next;
}LNode;

void createLinkList(LNode *&head);
void showLinkList(LNode *head);
void mergeLinkList(LNode *head1, LNode *head2, LNode *&head3);
using namespace std;

int main(){
    LNode *h1,*h2,*h3;
    //连续创建三个表
    createLinkList(h1);
    createLinkList(h2);
    createLinkList(h3);
    //展示创建结果
    showLinkList(h1);
    showLinkList(h2);
    showLinkList(h3);
    //合并h1,h2到h3
    mergeLinkList(h1, h2, h3);
    //展示合并结果
    showLinkList(h3);
    return 0;
}

void createLinkList(LNode *&head){
    head = (LNode*)malloc(sizeof (LNode));
    head->next=nullptr;
    int data;
    LNode *p,*tail=head;
    cout << "**********尾插法**********(退出值:9999)" << endl;
    while(true){
        cout << "请输入结点的值:";
        cin >> data;
        if(data == 9999){
            break;
        }
        p = (LNode*)malloc(sizeof (LNode));
        tail->next = p;
        p->data = data;
        p->next = nullptr;
        tail = p;
    }
    cout << "结束成功!" << endl;
}

void showLinkList(LNode *head){
    cout << "【";
    int flag = 0;
    while(head->next!= nullptr){
        if(flag==0){
            head = head->next;
            cout << head->data;
            flag = 1;
        }
        if(head->next== nullptr){
            break;
        }
        head = head->next;
        cout << " " << head->data;
    }
    cout << "】" << endl;
    cout << "打印完毕!" << endl;
}

void mergeLinkList(LNode *head1, LNode *head2, LNode *&head3){
    if(head1->next== nullptr){
        head3 = head2;
        return;
    }
    if(head2->next== nullptr){
        head3 = head1;
        return;
    }
    head1 = head1->next;
    head2 = head2->next;
    LNode *tail = head3;
    while(true){
        if(head1->data>head2->data){
            do {
                LNode *p;
                p = (LNode*)malloc(sizeof (LNode));
                tail->next = p;
                p->next = nullptr;
                p->data = head2->data;
                head2 = head2->next;
                tail = tail->next;
                tail->next = nullptr;
            }while(head2!= nullptr && head1->data>head2->data);
            if(head2== nullptr){
                while(head1!= nullptr){
                    LNode *p;
                    p = (LNode*)malloc(sizeof (LNode));
                    tail->next = p;
                    p->next = nullptr;
                    p->data = head1->data;
                    head1 = head1->next;
                    tail = tail->next;
                    tail->next = nullptr;
                }
                break;
            }
        }else{
            do {
                LNode *p;
                p = (LNode*)malloc(sizeof (LNode));
                tail->next = p;
                p->next = nullptr;
                p->data = head1->data;
                head1 = head1->next;
                tail = tail->next;
                tail->next = nullptr;
            }while(head1!= nullptr && head1->data<=head2->data);
            if(head1== nullptr){
                while(head2!= nullptr){
                    LNode *p;
                    p = (LNode*)malloc(sizeof (LNode));
                    tail->next = p;
                    p->next = nullptr;
                    p->data = head2->data;
                    head2 = head2->next;
                    tail = tail->next;
                    tail->next = nullptr;
                }
                break;
            }
        }
    }
}

结果截图:

图1:插值建立两个新链表 

 

图2:新链表只建立,不插值

  • 1
    点赞
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 可以使用双指针法,分别指向两个链表的头结点,比较两个指针所指节点的值,将较小的节点插入到新链表中,并将指针后移,直到其中一个链表为空。最后将另一个链表剩余的节点直接插入到新链表的末尾即可。这样得到的新链表就是非递减的有序单链表。 ### 回答2: 题目描述: 给定两个递增的有序单链表,要求将它们合并成一个非递减的有序单链表。 思路分析: 题目要求合并两个递增的有序单链表,那么首先需要明确,对于两个有序单链表,我们可以使用指针依次去比较它们的值,然后将小的节点逐个插入到一个新的链表中,由于两个原先都是递增的单链表,因此合并起来后也是递增的。需要注意的是,对于新的链表,我们需要制定一个头结点。 算法步骤: 1. 声明一个新链表的头结点,同时让头结点的下一个节点指向空。 2. 从链表1和链表2的头结点开始,比较两个节点的值大小,将小的节点插入新链表的尾部,然后将指向小节点的指针向后移动一位。 3. 重复第二步操作,直到两个链表有一个为空,此时,只需要将不为空的那个链表中的剩余节点直接插入到新链表的尾部即可。 4. 返回新链表的头结点。 算法实现实现的代码如下所示: ```python class Node: def __init__(self, val=0, next=None): self.val = val self.next = next def mergeTwoLists(l1: Node, l2: Node) -> Node: # 设置头结点 head = Node(-1) # 设置移动指针 cur = head # 循环比较两个有序链表的节点值 while l1 and 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 if l1 else l2 # 返回头结点的下一个节点 return head.next ``` 时间复杂度: 遍历两个链表,时间复杂度为O(m+n)。 空间复杂度: 新建一个链表,空间复杂度为O(m+n)。 总结: 本题要求将两个递增的有序单链表合并成一个非递减的有序单链表。通过比较其节点值,将小的节点一个一个插入到新链表的尾部中,并让移动指针向后移动。当其中一个链表为空时,只需将另一个链表中的剩余节点直接插入到新链表的尾部,最后返回头结点的下一个节点,即为所求的合并链表。本题的时间复杂度为O(m+n),空间复杂度为O(m+n)。 ### 回答3: 如果我们将两个有序链表进行归并,则我们可以很容易地处理这个问题。我们从开头开始遍历两个链表,每次选择值较小的节点添加到新的链表中。在选择后,我们移动指向较小节点的指针。这样,我们可以保持交替移动两个链表,直到它们都到达末尾。 实际上,我们可以使用递归的方法来合并两个有序链表。我们定义一个新的指针作为头节点,并在两个链表中遍历它们。每次我们选取两个链表中较小值的节点,将其加入新链表中。然后,我们在剩下的链表中递归地调用merge()函数,直到一个链表为空,然后将剩下的链表添加到新的链表中。我们最后返回新的链表。 代码如下所示: ``` ListNode merge(ListNode l1, ListNode l2) { if (l1 == null) { return l2; } if (l2 == null) { return l1; } if (l1.val < l2.val) { l1.next = merge(l1.next, l2); return l1; } else { l2.next = merge(l1, l2.next); return l2; } } ``` 这个函数会递归地将两个链表合并成一个非递减的有序链表,如果其中一个链表为空,它会返回另一个链表

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值