将两个有序链表合并

题目:已知两个链表head1 和head2 各自有序,请把它们合并成一个链表依然有序。(保留所有结点,即便大小相同)

循环实现:

1.重新申请一个头结点,使用指针p指向他,每新加一个结点,就将指针p后移一位,即指针p永远指向新链表的尾结点

2.由于所用链表第一个结点不赋值,因此指针需要开始从头结点的下一个结点开始判断,如果两个指针都为非空,将data域较小的指针连在新链表的末尾

3.当两个指针有一个到达链表的结尾时,将没有到达末尾的链表连接到新链表之后

递归实现:

1.函数返回条件是有一个链表结束,则返回另一个链表

2.取两个指针data域较小的作为新的头结点,递归调用

实现代码如下:

#include<iostream>
using namespace std;
struct listnode
{
    int data;
    listnode *next;
};
//尾插法创建链表
listnode *init()
{
    listnode *head=new listnode;
    head->next=NULL;
    listnode *p=head;
    cout<<"please input a number(按-1结束)"<<endl;
    int data;
    cin>>data;
    while(data!=-1)
    {
        listnode *temp=(listnode *)malloc(sizeof(listnode));
        temp->data=data;
        temp->next=p->next;
        p->next=temp;
        p=temp;
        cout<<"please input a number(按-1结束)"<<endl;
        cin>>data;
    }
    return head;
}
//打印链表
void print(listnode *head)
{
    listnode *p=head->next;
    while(p)
    {
        cout<<p->data<<"    ";
        p=p->next;
    }
    cout<<endl;
}
//将两个有序链表合并(循环实现)
listnode *hebing(listnode *head1,listnode *head2)
{
    listnode *head=new listnode;
    head->next=NULL;
    //声明两个指针分别指向两个链表的数据开始部分
    listnode *p1=head1->next;
    listnode *p2=head2->next;
    //声明一个指针来指向新链表的最后一个结点,开始时指向head
    listnode *last=head;
    while(p1!=NULL && p2!=NULL)
    {
        //p1结点的数据小:将last指向p1结点,last和p1分别后移
        if(p1->data<p2->data)
        {
            last->next=p1;
            p1=p1->next;
            last=last->next;
        }
        //p2结点数据小:将last指向p2结点,last和p2分别后移
        else
        {
            last->next=p2;
            p2=p2->next;
            last=last->next;
        }
    }
    //当有一个链表结束时候,将last指向还未结束的链表
    if(p1==NULL)
        last->next=p2;
    else if(p2==NULL)
        last->next=p1;
    return head;
}
//将两个有序链表合并(递归实现)
listnode *hebing2(listnode *head1,listnode *head2)
{
    //循环结束条件:当一个链表到达结尾
    if(head1==NULL)
        return head2;
    if(head2==NULL)
        return head1;
    listnode *head=NULL;
    //选择两个头结点中较小的作为头结点
    if(head1->data>head2->data)
    {
        head=head2;
        head->next=hebing2(head1,head2->next);
    }
    else
    {
        head=head1;
        head->next=hebing2(head1->next,head2);
    }
    return head;
}
//因为输出时候第一个结点时空的,需要填加一个空的头结点
listnode *diguihebing(listnode *head1,listnode *head2)
{
    listnode *head=new listnode;
    head->next=hebing2(head1->next,head2->next);
    return head;
}

测试代码以及运行结果:

int main()
{
    listnode *head1=init();
    print(head1);
    listnode *head2=init();
    print(head2);
    //listnode *head=hebing(head1,head2);//测试循环代码
    //print(head);
    listnode *head=diguihebing(head1,head2);//测试递归代码
    print(head);
    delete head,head1,head2;
    return 0;
}

时间: 2024-10-20 09:56:33

将两个有序链表合并的相关文章

将两个有序链表合并成一个有序链表

问题定义: 写一个函数SortedMerge函数,该函数有两个参数,都是递增的链表,函数的功能就是合并这两个递增的链表为一个递增的链表,SortedMerge的返回值是新的链表.新链表由前两个链表按元素递增顺序合并而成,也就是说它不会创建新的元素. 比如:这里有两个链表,分别是 list1: 5->10->15 list2: 2->3->20 SortedMerge函数返回一个指向新链表的指针,新链表应该是如下这样的:2->3->5->10->15->

两个有序链表合并

1.两个链表都带有头结点 Node* Merge(Node* head1, Node* head2) { if(head1==NULL || head1->next==NULL) return head2; if(head2==NULL || head2->next==NULL) return head1; Node* p1=NULL; Node* p2=NULL; Node* head=NULL; //找出两个链表中第一个结点较小的结点,head记录较小结点的头结点 if(head1->

将两个有序链表合并,合并后仍然有序

思路:因为A,B链表中元素有序,要使归并后的C也有序,可以每次从A.B中挑出最小的元素插入C的尾部,这样循环插入完成后,C也一定是有序的. 1 struct LinkList{ 2 int data; 3 LinkList *next; 4 } 5 6 void Merge(LinkList *A,LinkList *B,LinkList *&C) 7 { 8 LinkList *p = A->next; // 定义p结点跟踪 A中的结点 9 LinkList *q = B->next

将两个有序链表合并为一个新链表

#include <iostream> #include <stdio.h> typedef struct _Node { int value; struct _Node *next; }Node; Node *MergeList(Node *listA, Node *listB); void PrintList(Node *head); int main() { Node lista, nodea, listb, nodeb, nodec; lista.value = 2; no

合并两个有序链表,合并后依然有序

PLinkList Merge(PLinkList pList1, PLinkList pList2) { PLinkList pList; PLinkList end; if (pList1 == NULL) { return pList2; } if (pList2 == NULL) { return pList1; } if (pList1 == pList2) { return pList1; } // 摘一个节点做为新头节点 if (pList1->data < pList2->

[leetcode] 21. 合并两个有序链表

21. 合并两个有序链表 两个有序链表合并为一个新的有序链表 class Solution { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { ListNode ans = new ListNode(Integer.MAX_VALUE); ListNode p = ans; while (l1 != null && l2 != null) { if (l1.val < l2.val) { p.next = l1; l

21. 合并两个有序链表

知乎ID: 码蹄疾 码蹄疾,毕业于哈尔滨工业大学. 小米广告第三代广告引擎的设计者.开发者: 负责小米应用商店.日历.开屏广告业务线研发:主导小米广告引擎多个模块重构: 关注推荐.搜索.广告领域相关知识; 题目 将两个有序链表合并为一个新的有序链表并返回.新链表是通过拼接给定的两个链表的所有节点组成的. 示例: 输入:1->2->4, 1->3->4输出:1->1->2->3->4->4 分析 有序链表合并,每次都取两个中较小的一个,直到其中一个遍历到

0009 合并两个有序链表

将两个有序链表合并为一个新的有序链表并返回.新链表是通过拼接给定的两个链表的所有节点组成的. 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 /** * Definition for singly-linked list. * public class ListNode { * public int val; * public ListNode next; * public ListNode(int x) { v

链表--合并两个有序链表

leetcode 21 将两个有序链表合并为一个新的有序链表并返回.新链表是通过拼接给定的两个链表的所有节点组成的. 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 还是采用递归的方法,先贴出代码: public ListNode mergeTwoLists(ListNode l1, ListNode l2) { if( l1 == null ) { return l2; } if( l2 == null ) {