Error message here!

Hide Error message here!

忘记密码?

Error message here!

请输入正确邮箱

Hide Error message here!

密码丢失?请输入您的电子邮件地址。您将收到一个重设密码链接。

Error message here!

返回登录

Close

力扣148——排序链表

death00 2020-01-14 20:57:41 阅读数:11 评论数:0 点赞数:0 收藏数:0

原题

在 O(n log n) 时间复杂度和常数级空间复杂度下,对链表进行排序。

示例 1:

输入: 4->2->1->3
输出: 1->2->3->4

示例 2:

输入: -1->5->3->4->0
输出: -1->0->3->4->5

原题url:https://leetcode-cn.com/probl...

解决

题目很明确,排序,对于时间复杂度和空间复杂度有要求,针对O(n log n),让我想到了归并排序快速排序,接下来我们各自来看看。

对了,这里先统一放一下节点类,单向链表中的节点,存储当前节点的值和后一个节点的引用。

Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}

归并排序

归并排序,说白了,就是先分解到最小单元,然后逐个进行合并并排序,这样在合并的时候,其实两个链表本身就是有序的,那么当有一个全部取完后,另一个可以直接拼接在最后面。

让我们看一下代码:

public class Solution {
public ListNode sortList(ListNode head) {
// 归并排序
if (head == null || head.next == null) {
return head;
}
// 先分隔,利用快慢指针分隔。
// 快指针先走,因为只有当空节点或1个节点才是终止条件,2个节点的时候,如果不让快指针先走,而是也指向head,那么2个节点永远不会被分隔,会陷入死循环
ListNode fast = head.next.next;
ListNode slow = head;
while (true) {
if (fast == null || fast.next == null) {
break;
}
fast = fast.next.next;
slow = slow.next;
}
// 后半部分的开头
ListNode second = slow.next;
second = sortList(second);
// 前半部分的开头
slow.next = null;
ListNode first = head;
first = sortList(first);
// 合并
ListNode result = new ListNode(0);
head = result;
while (first != null && second != null) {
if (first.val < second.val) {
result.next = first;
first = first.next;
} else {
result.next = second;
second = second.next;
}
result = result.next;
}
if (first != null) {
result.next = first;
} else {
result.next = second;
}
return head.next;
}
}

提交OK,执行用时:5 ms,内存消耗:39.6 MB,执行用时只战胜了59.07%的 java 提交记录,应该还有优化的空间。

归并排序——优化

针对上面的代码,在分隔的时候,设置fast = head.next.next,这是因为我们设置的递归终止条件是针对null或者单个节点的。其实当只剩下两个节点的时候,就可以进行排序了,这样应该可以节省近一半的时间,当然了,从时间复杂度上来说并没有改变。

我们看一下代码:

public class Solution {
public ListNode sortList(ListNode head) {
// 归并排序
if (head == null || head.next == null) {
return head;
}
// 说明只有两个节点
if (head.next.next == null) {
ListNode second = head.next;
if (head.val > second.val) {
return head;
} else {
second.next = head;
head.next = null;
return second;
}
}
// 先分隔,利用快慢指针分隔。
ListNode fast = head;
ListNode slow = head;
while (true) {
if (fast == null || fast.next == null) {
break;
}
fast = fast.next.next;
slow = slow.next;
}
// 后半部分的开头
ListNode second = slow.next;
second = sortList(second);
// 前半部分的开头
slow.next = null;
ListNode first = head;
first = sortList(first);
// 合并
ListNode result = new ListNode(0);
head = result;
while (first != null && second != null) {
if (first.val < second.val) {
result.next = first;
first = first.next;
} else {
result.next = second;
second = second.next;
}
result = result.next;
}
if (first != null) {
result.next = first;
} else {
result.next = second;
}
return head.next;
}
}

执行用时,有的时候是4 ms,有的时候是3 ms,看来归并排序这条路差不多就是这样了。

快速排序

快速排序的思想就是选择一个标准值,将比它大的和比它的小的,做交换。针对链表这种结构,就是将比它大的放在一个链表中,比它小的放在一个链表中,和它一样大的,放在另一个链表中。然后针对小的和大的链表,继续排序。最终将三个链表按照小、相等、大进行连接。

接下来让我们看看代码:

class Solution {
public ListNode sortList(ListNode head) {
// 利用快排
// 单个节点是终止节点
if (head == null || head.next == null) {
return head;
}
// 比标准值小的节点
ListNode lowHead = new ListNode(0);
ListNode low = lowHead;
// 和标准值一样的节点
ListNode midHead = new ListNode(0);
ListNode mid = midHead;
// 比标准值大的节点
ListNode highHead = new ListNode(0);
ListNode high = highHead;
// 标准值
int val = head.val;
ListNode node = head;
// 遍历
while (node != null) {
// 比标准值大的节点
if (node.val > val) {
high.next = node;
high = high.next;
}
// 比标准值小的节点
else if (node.val < val) {
low.next = node;
low = low.next;
}
// 和标准值一样的节点
else {
mid.next = node;
mid = mid.next;
}
node = node.next;
}
// 终止,避免造成环
low.next = null;
high.next = null;
lowHead.next = sortList(lowHead.next);
highHead.next = sortList(highHead.next);
// 找出小节点链表的末尾
low = lowHead;
while (low.next != null) {
low = low.next;
}
// 拼接
low.next = midHead.next;
mid.next = highHead.next;
return lowHead.next;
}
}

提交OK,执行用时:2 ms,内存消耗:40.01 MB

和归并排序相比,时间更短,至于原因,我确实是没有想明白,因为都需要比较,然后重新构造新链表。我猜测是测试数据离散程度更高,这样归并排序的话,并没有充分利用其特性:

当两个链表合并时,如果一个链表已经全部结束,另一个链表剩余的部分可以直接拼接。

总结

以上就是这道题目我的解答过程了,不知道大家是否理解了。针对它的时间复杂度要求,利用归并排序或者快速排序解决。

有兴趣的话可以访问我的博客或者关注我的公众号、头条号,说不定会有意外的惊喜。

https://death00.github.io/

公众号:健程之道

版权声明
本文为[death00]所创,转载请带上原文链接,感谢
https://segmentfault.com/a/1190000021583775