Leetcode--合并两个有序链表(21)

题目描述:将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

单链表的定义

思路:思路一,将遍历两个链表存入列表中,对列表进行排序后再输出即可。思路二:递归方法。思路三:迭代方法。

(1)思路一:使用sort函数列表中的元素从小到大排列,然后遍历列表,以链表的形式输出即可。对本人来说不太熟练的地方在于,如何将列表中的元素以链表的形式输出。首先定义一个空链表node作为中间链表 Listnode(Node) , 用一个ans指向这个中间链表的地址。

 1 class Solution:
 2     def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
 3         #用列表的方法
 4         if l1 is None or l2 is None:
 5             return l2 or l1
 6         node = ListNode(None) #创建空链表的空头节点
 7         ans = node  #ans指向node链表
 8         temp_list = []
 9         while l1:
10             temp_list.append(l1.val)
11             l1 = l1.next
12         while l2:
13             temp_list.append(l2.val)
14             l2 =l2.next
15         temp_list.sort()
16         for i in range(len(temp_list)):
17             node.val = temp_list[i]
18             if i < len(temp_list)-1:
19                 node.next = ListNode(None)  #创建一个新的空next节点
20                 node = node.next
21         return ans

时间复杂度:由于sort()函数的时间复杂度为O(nlogn),因此本算法的时间复杂度为O((m+n)log(m+n))  空间复杂度:O(m+n)

(2)思路二:递归方法。

 1 class Solution:
 2     def mergeTwoLists(self, l1, l2):
 3         if l1 ==  None or l2 == None:
 4             return l2 or l1
 5         if l1.val < l2.val:
 6             l1.next = self.mergeTwoLists(l1.next,l2)
 7             return l1
 8         else:
 9             l2.next = self.mergeTwoLists(l1,l2.next)
10             return l2

递归方法的主要问题在于要找出递归公式。

(3)思路三:迭代法。用指针head指向要返回链表的头节点,pre表示当前节点。当链表l1中节点的值比较小时,则pre.next指向该节点,并更行pre到当前节点,同时l1中的指针也移动到下一个节点。

 1 class Solution:
 2     def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
 3         #迭代方法
 4         head = Listnode(-1)
 5         pre = head
 6         while l1 and l2:
 7             if l1.val <= l2.val:
 8                 pre.next = l1
 9                 l1 = l1.next
10             else:
11                 pre.next = l2
12                 l2 = l2.next
13             pre =pre.next
14         pre = l1 if l1 is not None else l2
15         return head.next

原文地址:https://www.cnblogs.com/shawn-young/p/12427255.html

时间: 2024-11-10 08:02:34

Leetcode--合并两个有序链表(21)的相关文章

LeetCode - 合并两个有序链表(No.21)

21 - 合并两个有序链表 date: Dec.28th, 2019 platform: windows thinking a recursive method is implemented. code /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct ListNode* mergeTwoLists(struct ListN

leetcode合并两个有序链表Java实现

将两个有序链表合并为一个新的有序链表并返回.新链表是通过拼接给定的两个链表的所有节点组成的. 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 两个有序链表的排序,实际上可以看成一个单链表使用归并排序的最后一个环节:“将两个排好序的子序列合并为一个子序列:每次都是从未比较的两个子序列的最小值中选出一个更小值”. /** * Definition for singly-linked list. * public cl

Leetcode合并两个有序链表

class Solution { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { if (l1 == null) { return l2; } else if (l2 == null) { return l1; } else if (l1.val < l2.val) { //计算下一节点 l1.next = mergeTwoLists(l1.next, l2); return l1; } else { l2.next = mer

LeetCode 21. 合并两个有序链表(Merge Two Sorted Lists)

21. 合并两个有序链表 21. Merge Two Sorted Lists 题目描述 将两个有序链表合并为一个新的有序链表并返回.新链表是通过拼接给定的两个链表的所有节点组成的. LeetCode21. Merge Two Sorted Lists 示例: 输入: 1->2->4, 1->3->4 输出: 1->1->2->3->4->4 Java 实现 ListNode 类 class ListNode { int val; ListNode n

[LeetCode]21 Merge Two Sorted Lists 合并两个有序链表

---恢复内容开始--- [LeetCode]21 Merge Two Sorted Lists 合并两个有序链表 Description 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. Example Example: Input: 1->2->4, 1-&g

[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

每天AC系列(七):合并两个有序链表

1 题目 LeetCode第21题,合并两个有序链表. 2 直接合并 因为已经有序了,类似归并排序中的合并一样,操作不难,直接上代码了. ListNode t = new ListNode(0); ListNode head = t; while(l1 != null && l2 != null) { if(l1.val < l2.val) { t.next = l1; l1 = l1.next; } else { t.next = l2; l2 = l2.next; } t = t

每天一个小算法(2)----合并两个有序链表

每天一个小算法还是有点没时间,尽量抽出时间写一写. 今天是合并有序的链表,对单链表有点忘了,尤其是指针指来指去的,有点晕,幸好基础还算好,想了想还是能想回来. 代码使用随机数函数生成一个链表,然后对链表排序,最后合并链表并打印,删除链表的函数于算法无关紧要,所以未实现^_^. 在Linux/g++下编译运行成功. 合并思路:和合并数组有些类同,比较两个节点的元素大小然后将小的摘下来尾插到链表bList中,然后指针指向下一个节点,最后直接把非空的链表合并到bList的末尾. 1 #include

链表(14)----合并两个有序链表

1.链表定义 typedef struct ListElement_t_ { void *data; struct ListElement_t_ *next; } ListElement_t; typedef struct List_t_{ int size; int capacity; ListElement_t *head; ListElement_t *tail; } List_t; 2.合并两个有序链表 ListElement_t * MergeList( ListElement_t *

合并两个有序链表

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