链表:合并两个有序的链表

题目描述

输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则。

解题思路

两种解法:递归和非递归

这个题目就是归并排序中的归并操作,将两个有序数组(链表)合并为一个有序的数组。

非递归:

第一个while循环,将 l1 和 l2 进行比较,谁小谁就合并到 listNode,直到 l1 或者 l2 为空

第二个while循环和第三个while循环,将 l1 或者 l2 剩下的节点合并到 listNode

最后返回的是 firstNode.next //头节点是不需要的

参考代码

递归:运行时间:27ms  占用内存:9564k

 1 /*
 2 public class ListNode {
 3     int val;
 4     ListNode next = null;
 5
 6     ListNode(int val) {
 7         this.val = val;
 8     }
 9 }*/
10 public class Solution {
11     public ListNode Merge(ListNode list1,ListNode list2) {
12         if(list1 == null) {
13             return list2;
14         }
15         if(list2 == null) {
16             return list1;
17         }
18         ListNode head = null;
19         if(list1.val < list2.val) {
20             head = list1;
21             head.next = Merge(list1.next, list2);
22         } else {
23             head = list2;
24             head.next = Merge(list1, list2.next);
25         }
26         return head;
27     }
28 }

非递归:运行时间:26ms  占用内存:9544k

 1 /*
 2 public class ListNode {
 3     int val;
 4     ListNode next = null;
 5
 6     ListNode(int val) {
 7         this.val = val;
 8     }
 9 }*/
10 public class Solution {
11     public ListNode Merge(ListNode l1, ListNode l2) {
12         ListNode listNode = new ListNode(0);
13         ListNode firstNode = listNode;
14         while (l1 != null && l2 != null) {  //将 l1 和 l2 进行比较,谁小谁就合并到 listNode,直到 l1 或者 l2 为空
15             if (l1.val <= l2.val) {
16                 listNode.next = l1;
17                 l1 = l1.next;
18             } else {
19                 listNode.next = l2;
20                 l2 = l2.next;
21             }
22             listNode = listNode.next;
23         }
24         while (l1 != null) {        //如果l2空了,就将剩余的l1加入到listNode中
25             listNode.next = l1;
26             l1 = l1.next;
27             listNode = listNode.next;
28         }
29         while (l2 != null) {        //如果l1空了,就将剩余的l2加入到listNode中
30             listNode.next = l2;
31             l2 = l2.next;
32             listNode = listNode.next;
33         }
34         return firstNode.next;
35     }
36 }

原文地址:https://www.cnblogs.com/carry6/p/11520868.html

时间: 2024-08-05 07:15:03

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

1.合并两个有序的链表

一.题目 合并两个有序的链表并使新链表也是有序排列. 二.算法实现 1 ListNode* Merge(ListNode* pHead1, ListNode* pHead2) 2 { 3 if (pHead1 == NULL) 4 return pHead2; 5 else if (pHead2 == NULL) 6 return pHead1; 7 ListNode *pNewHead = NULL, *pNode1 = NULL, *pNode2 = NULL; 8 if (pHead1->

Leetcode:Merge Two Sorted Lists 合并两个有序单链表

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists. 代码如下: * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x

算法题——合并两条有序的链表

题目:给定两个已排序的链表,返回合并后的链表. 思路:将链表L2的每个结点插入到链表L1中,时间复杂度为O(m+n),m.n分别为两条链表的长度. 代码: 1 struct ListNode 2 { 3 int value; 4 ListNode *next; 5 ListNode(int v): value(v), next(NULL) 6 { 7 } 8 }; 9 10 ListNode *mergeSortedList(ListNode *L1, ListNode *L2) 11 { 12

合并两个有序单链表

给出两个有序的单链表,将这两个单链表进行合并,合并出来的链表仍然是有序的. 比如给出链表1:1->3->6->7;链表2:2->4->5->8->9 合并后的链表为:1->2->3->4->5->6->7->8->9 代码展示如下(只给出实现部分) 结构体定义: typedef struct LinkNode { DataType data; struct LinkNode *next; }LinkNode,*pLi

算法题:合并两个有序的链表

说明:本文仅供学习交流,转载请标明出处,欢迎转载! 题目:已知有两个有序的单链表,其头指针分别为head1和head2,实现将这两个链表合并的函数: Node* ListMerge(Node *head1,Node *head2) 这个算法很像我们排序算法中的归并排序,只能说“很像”,因为思想是一样的,但是这个与归并排序还是有区别的,区别如下:      1.归并排序是针对有序数组,而这里是有序链表:        2.归并排序排序的时间复杂度为o(nlogn),而这里的时间复杂度最坏情况下为O

合并两个有序的链表

题目:输入两个递增排序的链表,合并这两个链表并使新链表中的结点仍然是按照递增排序的.例如输入两个链表分别1,3,5和2,4,6,合并后的链表则是1,2,3,4,5,6. 链表结点定义如下: typedef struct ListNode { int val; struct ListNode *p_next; }NODE, *PNODE; 拿到这个题目我们就来分析一下:首先分析合并两个链表的过程,我们从头结点开始.假设有两个这样的链表:                               

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

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 ) {

合并两个有序单链表的操作

/*以合并两个2个长度均为n的递增单链表为例 演示连个单链表的合并操作*/ #include<iostream>#include<algorithm>#include<cstring>#include<vector>#include<stdio.h>#include<queue>#include<math.h>#define INF 0x3f3f3f3f#define MAX 1000005#define Temp 100

剑指OFFER——合并两个有序的链表

输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则. 再做这道题就是想不起来书上怎么做的了,但是最近看STL里面全是这种基础的合并啊,比较啊.就算不会也看会了. 循环我用了4个指针.p和q分别指向两个链表当前需要比较的元素,l和k分别代表“新”的链表的旧节点和新节点,防止断了. 每次新比较的结果给k,l代表之前的节点. 循环: /* struct ListNode { int val; struct ListNode *next; ListNode(int