Middle-题目97:148. Sort List

原创 2016年05月31日 19:51:22

题目原文:
Sort a linked list in O(n log n) time using constant space complexity.
题目大意:
对一个单链表排序,要求时间复杂度O(nlogn),空间复杂度O(1)
题目分析:
参考discuss中的算法,使用快排,取pivot为第一个节点值。
源码:(language:java)

public class Solution {
    public ListNode sortList(ListNode h){
        if(h == null || h.next == null)
            return h;

        /*split into three list*/
        ListNode fakesmall = new ListNode(0), small = fakesmall;
        ListNode fakelarge = new ListNode(0), large = fakelarge;
        ListNode fakeequal = new ListNode(0), equal = fakeequal;

        ListNode cur = h; // pivot is h.
        while(cur != null){
            if(cur.val < h.val){
                small.next = cur;
                small = small.next;
            }
            else if(cur.val == h.val){
                equal.next = cur;
                equal = equal.next;
            }
            else{
                large.next = cur;
                large = large.next;
            }

            cur = cur.next;
        }

        // put an end.
        small.next = equal.next = large.next = null;
        // merge them and return . merge reusing below one. merge for quicksort should be simplified. 
        return merge(merge(sortList(fakesmall.next), sortList(fakelarge.next)),fakeequal.next) ;
    }
    private ListNode merge(ListNode h, ListNode m){
        ListNode fake = new ListNode(0), cur = fake;

        while(h != null && m != null){

            if(h.val < m.val){
                cur.next = h;
                h = h.next;
            }
            else{
                cur.next = m;
                m = m.next;
            }
            cur = cur.next;
        }

        cur.next = (h == null ? m : h);

        return fake.next;
    }
}

成绩:
8ms,beats 42.09%,众数8ms,31.36%
cmershen的碎碎念:
数组的快排中pivot是使用三者取中法,而链表不是随机存取的,使用三者取中法要遍历一次链表,反而不能加速。

版权声明:完整版Leetcode题解请出门左转https://github.com/cmershen1/leetcode/tree/master/docs

js数组的sort排序详解

转载地址: http://www.cnblogs.com/longze/archive/2012/11/27/2791230.html` sort()对数组排序,不开辟新的内存,对原...
  • xyr05288
  • xyr05288
  • 2016年01月15日 10:31
  • 1752

Meet-in-the-middle思想的一些应用

 Meet in the middle(有时候也叫作split and merge)是一种用以获取足够高效解决方案的灵巧的思想。和分治思想非常类似,它将问题分割成两个部分,然后试着合并这两个子问...
  • lishuandao
  • lishuandao
  • 2015年10月16日 17:46
  • 1995

c#范型List的Sort方法详解

.net2005中的范型List类的Sort方法有四种形式,分别是   1,不带有任何参数的Sort方法----Sort();   2,带有比较器参数的Sort方法 ----Sort(ICompa...
  • e295166319
  • e295166319
  • 2016年08月26日 15:56
  • 1283

LeetCode 148. Sort List--O(nlogn)时间复杂度和常数空间复杂度给链表排序

Sort a linked list in O(n log n) time using constant space complexity. package com.main; class Lis...
  • u010002184
  • u010002184
  • 2017年08月06日 20:33
  • 158

LeetCode之148_Sort List

LeetCode之Sort List 时间复杂度为O(n log n),空间复杂度为常量的单链表排序算法
  • firechungelaile
  • firechungelaile
  • 2014年11月01日 19:22
  • 653

leetcode148 Sort List

leetcode148 Sort List 题目内容 算法分析相对于时间复杂度为O(nlogn)的排序算法,有快速排序和归并排序。这里采用的是归并排序。思路大致如下: 归并排序的大致思想就是,将链表...
  • RheaWang
  • RheaWang
  • 2017年06月18日 12:48
  • 183

148. Sort List (python)

Sort a linked list in O(n log n) time using constant space complexity. 思路:能够有O(n lgn)时间复杂度的算法为,快速排序...
  • qq_28119401
  • qq_28119401
  • 2016年09月19日 22:12
  • 239

Leetcode148:Sort List

148. Sort List Sort a linked list in O(n log n) time using constant space complexity.
  • zhenzhangcs
  • zhenzhangcs
  • 2016年11月30日 16:17
  • 87

Sort List - LeetCode 148

题目描述 : Sort a linked list in O(n log n) time using constant space complexity. Hide Tags Linked Lis...
  • bu_min
  • bu_min
  • 2015年06月13日 21:02
  • 240

148. Sort List\191. Number of 1 Bits\476. Number Complement\342. Power of Four

题目描述 代码实现题目描述Sort a linked list in O(n log n) time using constant space complexity.对一个链表进行排序,时间复杂度为O...
  • c602273091
  • c602273091
  • 2017年04月03日 21:13
  • 271
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Middle-题目97:148. Sort List
举报原因:
原因补充:

(最多只允许输入30个字)