LootCode-链表排序-Java
链表排序
0.来源
来源:力扣(LeetCode) 题目链接:https://leetcode-cn.com/problems/sort-list
1.题目描述
在 O(n log n) 时间复杂度和常数级空间复杂度下,对链表进行排序。
2.测试用例
示例 1:
输入: 4->2->1->3
输出: 1->2->3->4
示例 2:
输入: -1->5->3->4->0
输出: -1->0->3->4->5
3.解题思路
3.1 总体思路
看到链表排序,给我的第一个反应就是应该是能实现,主要是我对这题有解题的思路,先不说时间复杂度和空间复杂度什么的,我感觉选择排序或者是插入排序应该都能实现对链表的排序
Talk is cheap show me the code..
好吧,上伪代码.(由于我主要用的是Java编程,所以就用Java 来实现了)
while(没有到最后一个节点){
Node cursorNode = currentNode.next;
while( cursorNode != null){
把找到比第一层循环节点的小的节点与它进行交换
cursorNode = cursorNode.next;
}
}
大概就是这样 ,和 选择排序实现差不多。
但是看题目: 需要时间复杂度 O(n log n) 还有 常数级别的空间复杂度,这个需要的时间复杂度,让我想起了归并排序,一看是也是没有想通,但是看了遍数组的归并排序和LeetCode上大佬们的题解就清晰思路了,下面是归并排序的基本思路
3.2归并排序思路说明
3.2.1 基本思想
总体概括就是从上到下递归拆分,然后从下到上逐步合并。
- 递归拆分:
先把待排序数组分为左右两个子序列,再分别将左右两个子序列拆分为四个子子序列,以此类推直到最小的子序列元素的个数为两个或者一个为止。
- 逐步合并:
将最底层的最左边的一个子序列排序,然后将从左到右第二个子序列进行排序,再将这两个排好序的子序列合并并排序,然后将最底层从左到右第三个子序列进行排序..... 合并完成之后记忆完成了对数组的排序操作(一定要注意是从下到上层级合并,可以理解为递归的层级返回)
3.2.2 算法步骤
- 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列;
- 设定两个指针,最初位置分别为两个已经排序序列的起始位置;
- 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置;
- 重复步骤 3 直到某一指针达到序列尾;
- 将另一序列剩下的所有元素直接复制到合并序列尾。
3.2.3 动态演示
3.2.4 算法特性
和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。
3.2.5 代码展示
/**
* 递归拆分
* @param arr 待拆分数组
* @param left 待拆分数组最小下标
* @param right 待拆分数组最大下标
*/
public static void mergeSort(int[] arr, int left, int right) {
int mid = (left + right) / 2; // 中间下标
if (left < right) {
mergeSort(arr, left, mid); // 递归拆分左边
mergeSort(arr, mid + 1, right); // 递归拆分右边
sort(arr, left, mid, right); // 合并左右
}
}
/**
* 合并两个有序子序列
* @param arr 待合并数组
* @param left 待合并数组最小下标
* @param mid 待合并数组中间下标
* @param right 待合并数组最大下标
*/
public static void sort(int[] arr, int left, int mid, int right) {
int[] temp = new int[right - left + 1]; // 临时数组,用来保存每次合并年之后的结果
int i = left;
int j = mid + 1;
int k = 0; // 临时数组的初始下标
// 这个while循环能够初步筛选出待合并的了两个子序列中的较小数
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
// 将左边序列中剩余的数放入临时数组
while (i <= mid) {
temp[k++] = arr[i++];
}
// 将右边序列中剩余的数放入临时数组
while (j <= right) {
temp[k++] = arr[j++];
}
// 将临时数组中的元素位置对应到真真实的数组中
for (int m = 0; m < temp.length; m++) {
arr[m + left] = temp[m];
}
}
3.3链表使用归并排序注意点
1.找到中间节点
解: 这个方法是使用 【slow fast 快慢双指针】 来完成的,听起来是挺高大上的,其实原理特别简单,就是一个每次向后挪动一个、另一个向后挪动两个,肯定是快指针的先到最后,而且是慢指针的二倍。 这就和跑步一样,如果一个人的速度是你的二倍,在相同时间内,他的路程肯定是你的二倍。
中间节点也根据节点个数来分开,如果是奇数个,中间节点就是中间,如果是偶数个中间节点就是中间位置的前一个节点 ,其实 把慢指针当作中间节点就可以了。
2.从中间节点断开,然后分别用这两个链表进行排序
如何断开: 就是将 slow指针的next节点用一个节点给保存下来当作右边链表的开始节点,并将slow指针的next设置成 null
4.代码实现
class ListNode {
int val;
ListNode next;
ListNode(int x) {
val = x;
}
}
public class LinkListSort {
public static ListNode sortList(ListNode head) {
// 设置递归终止条件:如果是一个节点,或者是 null 就可以返回
if ( head == null || head.next == null)
{
return head;
}
// 通过 快慢双指针 来寻找链表分割的点
ListNode slowNode = head;
ListNode fastNode = head.next;
while (fastNode!=null && fastNode.next!=null)
{
slowNode = slowNode.next;
fastNode = fastNode.next.next;
}
// 设置右部分链表的开始部分
ListNode temp = slowNode.next;
// 从中间断开链表
slowNode.next = null;
ListNode leftNode = sortList((ListNode) head);
ListNode rightNode = sortList((ListNode) temp);
//设置一个新的头节点来保存排序后的效果
ListNode cursorNode = new ListNode(0);
ListNode resNode = cursorNode;
// 对两个链表进行排序
while ( leftNode!=null && rightNode!=null)
{
if(leftNode.val < rightNode.val)
{
cursorNode.next= leftNode;
leftNode = leftNode.next;
}else{
cursorNode.next = rightNode;
rightNode = rightNode.next;
}
// 将指针节点向后移动
cursorNode = cursorNode.next;
}
// 判断两条链表是否循环到结尾,如果没循环到结尾将未循环完的挂在上面
cursorNode.next = leftNode == null ? rightNode : leftNode;
return resNode.next;
}
public static void main(String[] args) {
ListNode head = new ListNode(4);
ListNode a = new ListNode(2);
ListNode b = new ListNode(1);
ListNode c = new ListNode(3);
head.next =a;
head.next.next = b;
head.next.next.next=c;
ListNode listNode = sortList2( head);
while ( listNode!=null )
{
System.out.print(listNode.val+" ");
listNode = listNode.next;
}
}
}
5.总结
1. 学习到了slow 和 fast 双指针, 2. 还有归并排序在指针上面使用的优点,不用在申请空间了,没有数组那么浪费空间,简直就是给链表量身定做的排序算法。
- [编程经验] Pandas中比较好用的几个方法
- [编程经验] Elasticsearch 初识
- 2017.10.26水题大作战部分题解
- 2017.10.27涩会题大乱斗部分题解
- 【 关关的刷题日记50】 Leetcode 345. Reverse Vowels of a String
- Day1上午解题报告
- 【 关关的刷题日记51】 Leetcode 67. Add Binary
- 【 关关的刷题日记53】 Leetcode 100. Same Tree
- Day1下午解题报告
- 【关关的刷题日记54】Leetcode 226. Invert Binary Tree
- Day2上午解题报告
- 【关关的刷题日记55】Leetcode 404. Sum of Left Leaves
- CSS选择器详解
- 前端开发必备之Emmet
- java教程
- Java快速入门
- Java 开发环境配置
- Java基本语法
- Java 对象和类
- Java 基本数据类型
- Java 变量类型
- Java 修饰符
- Java 运算符
- Java 循环结构
- Java 分支结构
- Java Number类
- Java Character类
- Java String类
- Java StringBuffer和StringBuilder类
- Java 数组
- Java 日期时间
- Java 正则表达式
- Java 方法
- Java 流(Stream)、文件(File)和IO
- Java 异常处理
- Java 继承
- Java 重写(Override)与重载(Overload)
- Java 多态
- Java 抽象类
- Java 封装
- Java 接口
- Java 包(package)
- Java 数据结构
- Java 集合框架
- Java 泛型
- Java 序列化
- Java 网络编程
- Java 发送邮件
- Java 多线程编程
- Java Applet基础
- Java 文档注释
- 性能分析(1)- Java 进程导致 CPU 使用率升高,问题怎么定位?
- 安全服务之安全基线及加固(三)Apache篇
- 使用docsify来管理文献
- Cypress系列(41)- Cypress 的测试报告
- SSRF绕过
- 性能测试必备知识(6)- 如何查看“CPU 上下文切换”
- flex布局 div盒子居中
- 使用Apple Configurator 2提取商店ipa or app文件
- Spring 自动装配模式之byType
- 使用ATOMac进行Mac自动化测试
- 【赵渝强老师】什么是Oracle的数据字典?
- antd 如何在 src目录下 引入 Public 目录下的文件
- (精编)Python与安全(三)SSTI服务器模板注入
- 一年经验Java开发0713面试
- 【分享】MicroBlaze大内部存储器(AXI BRAM)设计