LeetCode OJ 292.Nim Gam148. Sort List

Sort a linked list in O(n log n) time using constant space complexity.

排序问题是我们遇到的一个老问题,从大一开始我们就学习了各种排序算法,大部分是基于数组的,比如冒泡排序,插入排序,快速排序等。这其中冒泡排序,插入排序的算法复杂度都是O(n2),插入排序的时间复杂度为O(nlogn)。对于这个题目,显然我们不能使用冒泡排序和插入排序,因为这样时间复杂度不满足要求,那么链表适合用快速排序吗?答案是肯定的,链表的结构还是非常方便使用快速排序的。

快速排序的特点是:如果待排序的数字列表越散乱,效果越好。如果数字列表是完全升序或者完全降序,快排的效果最差。最好情况下时间复杂度为O(nlogn),最坏情况为O(n2)。

快速排序的思想是:1.选一个key值;2.把小于key值的数移到key的左边;3.把大于key值的数移到key的右边;4.对左半部分和右半部分使用快速排序算法。

在对链表进行快速排序时,我们可以选择头结点作为key值,然后遍历链表,把比头结点val值小的节点和比头结点val值大的节点拆分到两个链表中。然后对这两个链表分别进行快速排序,然后把这三部分组装起来就好了。代码如下:

 1 public class Solution {
 2     public ListNode sortList(ListNode head) {
 3         if(head==null || head.next==null) return head;
 4
 5         ListNode lefthead = null;
 6         ListNode righthead = null;
 7         ListNode mid = head;
 8         head = head.next;
 9         mid.next = null;
10         ListNode midtail = mid;
11
12         while(head!=null){  //把链表拆分成三部分
13             ListNode temp = head;
14             head = head.next;
15             if(temp.val < mid.val){     //比head.val小的部分
16                 temp.next = lefthead;
17                 lefthead = temp;
18             }
19             else if(temp.val == mid.val){
20                 temp.next = mid;
21                 mid = temp;
22             }
23             else{
24                 temp.next = righthead;  //比head.val大的部分
25                 righthead = temp;
26             }
27         }
28
29         righthead = sortList(righthead);//把三部分组装起来
30         if(lefthead==null){
31             midtail.next = righthead;
32             return mid;
33         }
34         lefthead = sortList(lefthead);
35
36         ListNode tmp = lefthead;
37         while(tmp.next!=null) tmp = tmp.next;
38         tmp.next = mid;
39         midtail.next = righthead;
40         return lefthead;
41     }
42 }
时间: 2024-10-27 07:12:37

LeetCode OJ 292.Nim Gam148. Sort List的相关文章

LeetCode OJ 292.Nim Gam19. Remove Nth Node From End of List

Given a linked list, remove the nth node from the end of list and return its head. For example, Given linked list: 1->2->3->4->5, and n = 2. After removing the second node from the end, the linked list becomes 1->2->3->5. Note:Given n

【一天一道LeetCode】#292. Nim Game.md

一天一道LeetCode 从今天开始,调整规律,不按顺序做,从easy开始! 本系列文章已全部上传至我的github,地址:ZeeCoder's Github 欢迎大家关注我的新浪微博,我的新浪微博 欢迎转载,转载请注明出处 (一)题目 You are playing the following Nim Game with your friend: There is a heap of stones on the table, each time one of you take turns to

LeetCode OJ:Nim Game(Nim游戏)

You are playing the following Nim Game with your friend: There is a heap of stones on the table, each time one of you take turns to remove 1 to 3 stones. The one who removes the last stone will be the winner. You will take the first turn to remove th

力扣(LeetCode)292. Nim游戏 巴什博奕

你和你的朋友,两个人一起玩 Nim游戏:桌子上有一堆石头,每次你们轮流拿掉 1 - 3 块石头. 拿掉最后一块石头的人就是获胜者.你作为先手. 你们是聪明人,每一步都是最优解. 编写一个函数,来判断你是否可以在给定石头数量的情况下赢得游戏. 示例: 输入: 4 输出: false 解释: 如果堆中有 4 块石头,那么你永远不会赢得比赛: 因为无论你拿走 1 块.2 块 还是 3 块石头,最后一块石头总是会被你的朋友拿走. 解析 这是巴什博奕 n=k*(m+1)+r n是要报的数,m是最多能报的数

&lt;LeetCode OJ&gt; Nim Game【292】

292. Nim Game My Submissions Question Total Accepted: 30675 Total Submissions: 61031 Difficulty: Easy You are playing the following Nim Game with your friend: There is a heap of stones on the table, each time one of you take turns to remove 1 to 3 st

LeetCode OJ平台上Sort Colors题目算法探讨

原题如下,意思就是说无序数组(由0,1,2组成),一遍扫描,把数组整理成若干个0-若干个1-若干个2这样的序列. Given an array with n objects colored red, white or blue, sort them so that objects of the same color are adjacent, with the colors in the order red, white and blue. Here, we will use the integ

[LeetCode OJ] Sort Colors

Given an array with n objects colored red, white or blue, sort them so that objects of the same color are adjacent, with the colors in the order red, white and blue. Here, we will use the integers 0, 1, and 2 to represent the color red, white, and bl

LeetCode OJ - Insertion Sort List

题目: Sort a linked list using insertion sort. 解题思路: 假设 list[1..i]是排好序的,找到第i+1个元素应该插入的位置及其前驱,然后将其插入. 代码: /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class S

LeetCode OJ - Sort List

题目: Sort a linked list in O(n log n) time using constant space complexity. 解题思路: 复杂度为O(n* logn) 的排序算法有:快速排序.堆排序.归并排序.对于链表这种数据结构,使用归并排序比较靠谱.递归代码如下: 代码: /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNod