面试题17:合并两个排序的链表

ListNode类(结点类)

 1 package leetcode.utilities;
 2
 3 public class ListNode {
 4     public int    val ;
 5     public ListNode   next ;
 6     public ListNode(int val) {
 7         // TODO Auto-generated constructor stub
 8         this.val = val;
 9         this.next = null ;
10     }
11     //打印链表
12         public static void PrintList(ListNode head){
13             System.out.println("PrinyList  start");
14             ListNode pNode = head ;
15             System.out.print("{ ");
16             while(pNode != null){
17                 System.out.print(pNode.val + " ");
18                 pNode= pNode.next;
19             }
20             System.out.println(" }");
21         }
22 }

递归实现Java代码:

 1 package com.hb.jzoffer;
 2
 3 import leetcode.utilities.ListNode;
 4 //面试题17:合并两个排序的链表
 5 public class MergeSortedLists {
 6     public ListNode merge(ListNode pHead1 , ListNode  pHead2){
 7         //判断两个链表是否为空
 8         if(pHead1 == null ){
 9             return pHead2;
10         }else if(pHead2 == null ){
11             return  pHead1;
12         }
13
14         ListNode  pMergedHead = null;
15
16         //递归调用
17         if(pHead1.val < pHead2.val){
18             pMergedHead = pHead1 ;
19             //下面递归调用自己,返回的值是pMergedHead后面的节点,一直到递归结束,才会返回pMergedHead新的头结点。
20             pMergedHead.next = merge(pHead1.next, pHead2) ;
21         }else{
22             pMergedHead = pHead2 ;
23             pMergedHead.next = merge(pHead1, pHead2.next);
24         }
25
26         return pMergedHead ;
27     }
28
29     public static void main(String[] args) {
30         ListNode head1 = new ListNode(1);
31         ListNode n1 = new ListNode(3);
32         ListNode n2 = new ListNode(5);
33         ListNode n3 = new ListNode(7);
34         ListNode n4 = new ListNode(9);
35
36         head1.next = n1 ;
37         n1.next = n2 ;
38         n2.next = n3 ;
39         n3.next = n4 ;
40
41         ListNode head2 = new ListNode(2);
42         ListNode n5 = new ListNode(4);
43         ListNode n6 = new ListNode(6);
44
45         head2.next = n5 ;
46         n5.next = n6;
47
48         MergeSortedLists  merge = new MergeSortedLists();
49
50         ListNode  mergeHead = merge.merge(head1, head2);
51
52         ListNode.PrintList(mergeHead);
53
54     }
55 }
时间: 2024-08-02 02:45:22

面试题17:合并两个排序的链表的相关文章

面试题 17:合并两个排序的链表

题目:输入两个递增排序的链表,合并这两个链表并使新链表中的结点仍然是按 照递增排序的. 两个指针指向两个链表的头结点,取其中值小的作为新链表的头结点,和之前的结点串联,如此递归. 注意用例: 两个链表都为null: 其中一个链表为null: 两个链表有多个结点,有相同的值,不同的值. package offer; /*面试题 17:合并两个排序的链表 题目:输入两个递增排序的链表,合并这两个链表并使新链表中的结点仍然是按 照递增排序的.*/ public class Problem17 { st

剑指offer面试题17——合并两个排序的链表

题目1519:合并两个排序的链表 题目描述: 输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则.(hint: 请务必使用链表.) 输入: 输入可能包含多个测试样例,输入以EOF结束.对于每个测试案例,输入的第一行为两个整数n和m(0<=n<=1000, 0<=m<=1000):n代表将要输入的第一个链表的元素的个数,m代表将要输入的第二个链表的元素的个数.下面一行包括n个数t(1<=t<=1000000):代表链表一中的元素.接

剑指offer-面试题17.合并两个排序的链表

题目:输入两个递增的排序的链表,合并这两个链表并使新链表中的节点仍然是 按照递增排序的.例如链表1链表2合并为链表3. 1 List1:1->3->5->7 2 3 List2:2->4->6->8 4 5 List3:1->2->3->4->5->6->7->8 链表结点定义如下: 1 struct ListNode 2 { 3 int m_nValue; 4 ListNode* m_pNext; 5 } 其实我们可以简单梳理

剑指offer 面试题17—合并两个排序的链表

题目: 输入两个递增排序的链表,合并这两个链表并使得新链表中的节点仍然是按照递增排序的. 基本思想: 当我们得到两个链表中值较小的头结点并把它连接到已经合并的链表之后,两个链表剩余的节点依然是排序的,因此合并的步骤和之前的而不周是一样的.这就是典型的递归的过程. #include <iostream> using namespace std; typedef int ElemType;//数据类型模板 typedef struct Node//结点 { ElemType data; struc

剑指offer之面试题17合并两个排序的链表

问题描述: 输入两个递增的链表,合并这两个链表并使新链表中的结点仍然是按照递增排序的. 实现代码如下: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> struct List{ int date; struct List *next; }; struct List* doMergeList(struct List *P1head,struct List *P2head){ if(P1head==NU

面试题17 合并两个排序的链表

题目描述 输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则. 1 /* 2 struct ListNode { 3 int val; 4 struct ListNode *next; 5 ListNode(int x) : 6 val(x), next(NULL) { 7 } 8 };*/ 9 class Solution { 10 public: 11 ListNode* Merge(ListNode* pHead1, ListNode* pHead2

《剑指offer》面试题17 合并两个排序的链表 Java版

我的方法:新初始化一个链表头,比较两个链表当前节点的大小,然后连接到该链表中.遍历两个链表直到null为止. public ListNode merge(ListNode first, ListNode second){ //注意这个细节 ListNode head = new ListNode(0); ListNode index = head; while(first != null && second != null){ if(first.val < second.val){

面试题:合并两个排序的链表

题目:输入两个递增排序的链表,合并这两个链表并使新链表中的节点仍然是递增的. 例如: /*合并两个排序的链表*/ /* 链表节点定义如下: struct ListNode { int _data; ListNode* _next; }; */ ListNode* MergeList(ListNode* pHead1, ListNode* pHead2) { if (pHead1 == NULL) //链表1为空链表 { return pHead2; } else if (pHead2 == NU

剑指offer_面试题17_合并两个排序的链表(两种思维)

题目:输入两个递增排序的链表,合并这两个链表,并使新链表中的结点仍然是按照递增排序的. 第一种思维:合并两个排序的链表,类似于合并两个排序数组,所不同的仅是一个用链表保存数据,一个用数组保存数据. 算法如下:(下面的算法前提是:头结点 不是 链表的第一个数据节点.) /**方法一:合并两个排序链表,使用了新创建的链表来保存,没有改动两个原始链表*/ ListNode *merge_tow_list(ListNode *pHead1,ListNode *pHead2) { if(NULL == p

17.合并两个排序的链表

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" > 当代码试图訪问空指针指向的内存时程序就会崩溃,从而导致鲁棒性问题.所以要对空链表单独处理. ListNode* Merge(ListNode* pHead1, ListNode* pHead2) { if (pHead1 == NULL) return