精华内容
下载资源
问答
  • 将两个升序链表合并为一个升序链表。 方法①:递归 struct ListNode { int val; ListNode* next; ListNode(int x):val(x),next(NULL){} }; class Solution { public: ListNode* mergeList(ListNode* l1, ...

    将两个升序链表合并为一个升序链表。

    方法①:递归

    struct ListNode
    {
      int val;
      ListNode* next;
      ListNode(int x):val(x),next(NULL){}
    };
    class Solution
    { 
       public:
          ListNode* mergeList(ListNode* l1, ListNode* l2)
          {
            if(l1==NULL) return l2;
            if(l2==NULL) return l1;
            ListNode* head;
            if(l1->val < l2->val)
            {
              head=l1;
              head->next=mergeList(l1->next, l2);
            }
            else
            {
              head=l2;
              head->next=mergeList(l1, l2->next);
            }
            return head;
          }
    }
    
    

    ②迭代

    class Solution
    {
      public:
         ListNode* mergeList(ListNode* l1,ListNode* l2)
         {
           if(l1==NULL) return l2;
           if(l2==NULL) return l1;
           ListNode* head=new ListNode(0);
           ListNode* p=head;
           while(l1 && l2)
           {
             if(l1->val < l2->val)
             {
               p->next=l1;
               l1=l1->next;
               p=p->next;
             }
             else
             {
               p->next=l2;
               l2=l2->next;
               p=p->next;
             }
           }
           p->next=l1?l1:l2;
           return head->next;
         }
    }
    
    展开全文
  • /*** 将两个升序链表合并为一个新的升序链表并返回。* 新链表是通过拼接给定的两个链表的所有节点组成的。*/public class MergeTwoList {/*** 思路是新建一个带头节点的链表,然后根据比较两个节点的值得大小,* 把...

    /**

    * 将两个升序链表合并为一个新的升序链表并返回。

    * 新链表是通过拼接给定的两个链表的所有节点组成的。

    */

    public class MergeTwoList {

    /**

    * 思路是新建一个带头节点的链表,然后根据比较两个节点的值得大小,

    * 把小的那个存到新建的链表中,之后判断是否两个链表中有一个没有遍历完,

    * 把它添加到尾部即可,然后返回头节点的下一个节点即可。

    * @param list1 链表一

    * @param list2 链表二

    * @return 新建的链表

    */

    public static ListNode mergerTwoList(ListNode list1, ListNode list2){

    ListNode head = new ListNode(0);

    ListNode result = head;

    while(list1 != null && list2 != null){

    if(list1.val >= list2.val){

    head.next = list2;

    head = head.next;

    list2 = list2.next;

    }else{

    head.next = list1;

    head = head.next;

    list1 = list1.next;

    }

    }

    if(list1 == null){

    head.next = list2;

    }else{

    head.next = list1;

    }

    return result.next;

    }

    public static void main(String[] args){

    ListNode head = new ListNode(1);

    ListNode node1 = new ListNode(2);

    ListNode node2 = new ListNode(4);

    ListNode node3 = new ListNode(3);

    ListNode node4 = new ListNode(5);

    head.next = node1;

    node1.next = node2;

    // node2.next = node3;

    node3.next = node4;

    ListNode result = mergerTwoList(head, node3);

    while (result != null){

    System.out.println(result.val);

    result = result.next;

    }

    }

    }

    class ListNode {

    int val;

    ListNode next;

    ListNode(int x) { val = x; }

    }

    展开全文
  • 两个升序链表合并成一个升序链表

    千次阅读 2018-09-09 18:13:31
    //将两个升序链表和并成一个升序序列 #include<stdio.h> #include<stdlib.h> typedef struct node { int data; struct node *next; }LinkNode; LinkNode* Creat_LinkList2() { int x; LinkNode* h; ...
    //将两个升序链表和并成一个升序序列 
    #include<stdio.h>
    #include<stdlib.h>
    typedef struct node
    {
        int data;
        struct node *next;
    }LinkNode;
    LinkNode* Creat_LinkList2()
    {
        int x;
        LinkNode* h;
        LinkNode *s,*t;
        printf("请输入链表的数据域的值");
        scanf("%d",&x);
        h=(LinkNode *)malloc (sizeof(LinkNode));
            h->next=NULL;
            t=h;
        while(x!=-1) 
        {
        s=(LinkNode *)malloc(sizeof(LinkNode));
            s->data=x;
            s->next=t->next;
            t->next=s;
            t=s;
            scanf("%d",&x);
        }
        return h;
    } 
    void PrintLink(LinkNode *h)
    {
        LinkNode *p;
        for(p=h->next;p;p=p->next)
        {
            printf("%5d",p->data);
        }
    } 
    LinkNode *MergeLink(LinkNode *head1,LinkNode *head2)
    {
        LinkNode*p,*t,*q;
        p=head1->next;
        q=head2->next;
        t=head1;
        while(q)
        {
            while(p!=NULL&&p->data<q->data)
            {
                t=p;
                p=p->next;
            }
            if(!p)
            {
                head2->next=NULL;
                //这个地方要用t而不是p,切记切记,p已经为空了 
                t->next=q;
            }
            else
            {
                head2->next=q->next;
                q->next=p;
                t->next=q;
                t=t->next;
            }
            q=head2->next;
        }
        return head1;
    }
    /*LinkNode *MergeLink(LinkNode *head1,LinkNode *head2)
    {
        LinkNode *p,*t;
        LinkNode *h=(LinkNode *)malloc(sizeof(LinkNode));
        h->next=NULL;
        t=h; 
        while(head1->next&&head2->next)
        {
            if(head1->next->data<head2->next->data)
            {
                p=head1->next;
                head1->next=p->next; 
            }
            else
            {
                p=head2->next;
                head2->next=p->next; 
            }
            p->next=NULL;
            t->next=p;
            t=p;
        }
        p=head1->next!=NULL?head1->next:head2->next;
        t->next=p;
        t=p;
        return h;    
    }*/
    //递归适合于不带表头结点的链表
    //用该方法返回的是一个不代表头节点的链表,输出的时候从第一个位置(head)开始输出 
    //但是以为我创建的都是带表头节点的,所以我在递归的函数中去掉了表头节点 
    /*LinkNode *MergeLink(LinkNode *head1,LinkNode *head2)
    {
    
        if(head1==NULL)
        return head2;
        if(head2==NULL)
        return head1;
        if(head1->data==100000)
        head1=head1->next;
        if(head2->data==100000)
        head2=head2->next; 
        LinkNode *p=(LinkNode *)malloc(sizeof(LinkNode));
        if(head1->data>head2->data)
        {
            p=head2;
            p->next=MergeLink(head1,head2->next);
        }
        else
        {
            p=head1;
            p->next=MergeLink(head1->next,head2);
        }
        return p;  
    }*/
    int main(void)
    {
    
        LinkNode *head1,*head2,*head3;
        //尾插创建链表 
        printf("请输入第一个升序链表\n"); 
        head1=Creat_LinkList2();
        printf("请输入第二个升序链表\n"); 
        head2=Creat_LinkList2();
        //以下两句注释在带递归方法的时候写 
    //    head1->data=100000;
    //    head2->data=100000;
        head3=MergeLink(head1,head2);
        PrintLink(head3);
        return 0;
    } 

     

    展开全文
  • 将两个升序链表合并成一个 升序链表 分析:  首先从自己熟悉的地方入手(《向程序员一样思考》)。想想数组,如何将两个升序的数组合并成一个升序的数组?肯定是依次比较数组中的每一位元素,将较小的数存放到新的...

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

    分析:

          首先从自己熟悉的地方入手(《向程序员一样思考》)。想想数组,如何将两个升序的数组合并成一个升序的数组?肯定是依次比较数组中的每一位元素,将较小的数存放到新的数组中(以空间换时间),但是要注意一点:两个数组的长度可能不同?如何解决呢,其实因为这是有序数组,只需将较长数组中多出的部分插到已排好序的新数组的后面就行了。

          那对于链表如何操作呢?将链表就两种方式:头插和尾插。只需将较小的结点从原链表头删,尾插到新链表中即可

     

    代码如下:

     

    
     
    ElemSN *MergerLink(ElemSN *h1 , ElenSN *h2)
    {
        //定义新链表头指针hn,和操作指针t,p
        ElemSN *hn,*t,*p;
        hn=NULL;
        //处理链表中相同长度的部分
        while(h1&&h2)
        {
            //头删
            if(h1->data < h2->data){
                p=h1;
                h1=h1->next; 
            } 
            else{
               p=h2;
               h2=h2->next;
            }
            //尾插到新链表中
            if(!hn)
               hn=t=p;
            else
              t=t->next=p;
        }
        //处理长短不齐的链表,处理多余的结点
           if(!h1)          //h2常于h1
               t->next=h2;
           else
               t->next=h1;
        
        return hn;
    }
    )
    {
        //定义新链表头指针hn,和操作指针t,p
        ElemSN *hn,*t,*p;
        hn=NULL;
        //处理链表中相同长度的部分
        while(h1&&h2)
        {
            //头删
            if(h1->data < h2->data){
                p=h1;
                h1=h1->next; 
            } 
            else{
               p=h2;
               h2=h2->next;
            }
            //尾插到新链表中
            if(!hn)
               hn=t=p;
            else
              t=t->next=p;
        }
        //处理长短不齐的链表,处理多余的结点
           if(!h1)          //h2常于h1
               t->next=h2;
           else
               t->next=h1;
        
        return hn;
    }
    

     

     

     

     

     

     

    展开全文
  • 将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 struct ListNode { int val; struct ListNode *next; }; struct ListNode* mergeTwoLists(struct ListNode* l1...
  • 将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->3->5, 2->4->6 输出:1->2->3->4->5->6 #include <stdio....
  • 将两个升序链表合并为一个新的升序链表并返回 解决思路 ①创建一个新链表 ②设置两个指针 (l1 , l2), 使它们分别指向两个链表的头结点. 用 l1, l2 遍历两个链表的同时, 比较两个链表的每一个结点元素的大小 将较小的...
  • Leetcode(23)——合并K个升序链表
  • 今日习题将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。示例 :输入: 1->2->4, 1->3->4输出: 1->1->2->3->4->4……⏰ 思考时间……...
  • 将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 二,解决思路 1,定义一个...
  • 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 我们可以用递归实现这个...
  • 将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 解题思路: /** * ...
  • 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 思路分析: 1.先创建一个哑节点demmy,再定义一个临时变量temp,用于遍历链表,temp = demmy; 2.执行判断语句...
  • * 将两个升序链表合并为一个新的升序链表并返回。 * 新链表是通过拼接给定的两个链表的所有节点组成的。 */ public class MergeTwoList { /** * 思路是新建一个带头节点的链表,然后根据比较两个节点的值得...
  • struct node*creat(int m)//链表创建 { struct node*head; struct node*p,*pre; int i,n=0; p=pre=(struct node*)malloc(LEN); scanf("%d ",&p->a); for(i=0;i;i++) { n++; if(n==1) { head=...
  • 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 解答: struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) { // 判断其中一个链表...
  • 分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net /* * Created by Chimomo */ #include &lt;iostream&......
  • leetCode 21题 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 迭代法 定义...
  • 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1: 输入:l1 = [1,2,4], l2 = [1,3,4] 输出:[1,1,2,3,4,4] 示例 2: 输入:l1 = [], l2 = [] 输出:[] ...
  • 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1: 输入:l1 = [1,2,4], l2 = [1,3,4] 输出:[1,1,2,3,4,4] 示例 2: 输入:l1 = [], l2 = [] 输出:[] ...
  • 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1: 输入:l1 = [1,2,4], l2 = [1,3,4] 输出:[1,1,2,3,4,4] 示例 2: 输入:l1 = [], l2 = [] 输出:[] ...
  • #include<stdio.h>...#include"toulianbiao.h"//与前文的“lianbiao.h”类似,此处为带表头结点的链表 void Delkeynode(ElemSN *head1,ElemSN *head2) { ElemSN *p,*tail,*h1=NULL,*s; while...
  • 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 我的解答 这次的速度...
  • 将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 链表的结构是: 链表可分为单向链表和双向链表。 一个单向链表包含两个值: 当前节点的值和一个指向下一个节点...
  • 两个升序链表合并为一个升序链表

    千次阅读 2020-06-29 20:04:39
    } 首先找到第一个结点较小或相等的链表记为 header1 ,while 循环找到 header1 中比 header2 要合并的数据元素大的结点的前驱结点,将 header 链表的头结点的后继结点连接到 header1 后面,继续比较header2的后继...
  • 直到其中某个链表为空了,那么就将另外一个链表的剩余部分全部插入到新链表的末尾 由于新链表是带傀儡节点的链表,最终返回新链表头节点的下一个节点即可 代码 public class Solution5 { public L
  • 合并K个升序链表

    2021-02-24 15:32:13
    合并K个升序链表,可以化为进行K-1次两个升序链表的合并,简单粗暴,直接遍历链表数组,将两个升序链表合并后的结果继续与下一个升序链表合并,直到链表数字中无需要合并的链表。代码暂无。 解法二: 采用分治法合并...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,325
精华内容 1,330
关键字:

升序链表