sort-list(Leetcode)

原创 2016年05月30日 18:10:53

题目描述

Sort a linked list in O(n log n) time using constant space complexity.
题意是在给定时间复杂度内对单链表进行排序。看到这个时间复杂度,第一反应是快速排序和归并排序。下图为主要排序算法的时间复杂度和空间复杂度。
这里写图片描述
归并排序稳定且空间复杂度为O(1),所以选择归并排序的思想解决该问题。

package sxd.learn.java.leetcode;

/**
 * 
 * @author lab 
 * 2016/5/24 
 * sort-list : Sort a linked list in O(n log n) time using
 *         constant space complexity.
 */
public class Leetcode4 {

    public static void main(String[] args) {

    }

    public ListNode sortList(ListNode head) {
        int size = 0;
        ListNode current = head;
        if (head == null || head.next == null)
            return head;
        while (current != null) {
            size++;
            current = current.next;
        }

        ListNode mid = head;
        int mid_size = (size - 1) / 2;
        for (int i = 1; i <= mid_size; i++)
            mid = mid.next;
        ListNode head2 = mid.next;
        mid.next = null;
        ListNode h1 = sortList(head);
        ListNode h2 = sortList(head2);
        ListNode result = merge(h1, h2);

        return result;
    }

    public ListNode merge(ListNode h1, ListNode h2) {
        if (h1 == null)
            return h2;
        if (h2 == null)
            return h1;

        ListNode head, cur, h1_cur = h1, h2_cur = h2;
        if (h1_cur.val < h2_cur.val) {
            head = h1_cur;
            cur = head;
            h1_cur = h1_cur.next;
        } else {
            head = h2_cur;
            cur = head;
            h2_cur = h2_cur.next;
        }

        while (h1_cur != null && h2_cur != null) {
            if (h1_cur.val < h2_cur.val) {
                cur.next = h1_cur;
                h1_cur = h1_cur.next;
            } else {
                cur.next = h2_cur;
                h2_cur = h2_cur.next;
            }
            cur = cur.next;
        }
        if (h1_cur != null)
            cur.next = h1_cur;
        if (h2_cur != null)
            cur.next = h2_cur;

        return head;
    }

}

class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
        next = null;
    }
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

[LeetCode]Insertion Sort List

Sort a linked list using insertion sort. /** * Definition for singly-linked list. * pub...

[leetcode]Insertion Sort List

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next...

LeetCode :: Insertion Sort List [详细分析]

Sort a linked list using insertion sort. 仍然是一个非常简洁的题目,让我们用插入排序给链表排序;这里说到插入排序,可以来回顾一下, 最基本的入门排序算法,就是...

LeetCode 之 Sort List — C 实现

Sort List   Sort a linked list in O(n log n) time using constant space complexity. 对链表进行排序,...

Leetcode刷题记——147. Insertion Sort List(插入排序链表)

一、题目叙述: Sort a linked list using insertion sort. 二、解题思路: Medium题,啊。。。我今天头晕脑胀,写的不太...

Sort List:from LeetCode

题目大意:用o(nlgn)时间复杂度和固定额外空间对链表进行paix

《leetCode》:Insertion Sort List

题目Sort a linked list using insertion sort.思路原以为可以直接在链表上利用插入排序来进行,单尝试了半天发现在链表上直接用插入排序有点困难,不可行,因此,就决定将...

LeetCode 147 Insertion Sort List

题意单链表的插入排序题解1:边界条件判断,如果单链表中head为空或只有head,直接返回 2:设置一个结点指针p指向head的下一个结点,将head后的无序表断开,等待排序 3:while循环开...

[LeetCode] 147. Insertion Sort List java

/**147. Insertion Sort List * @param head * @return 链表,使用插入排序 */ public ListNode...

LeetCode之148_Sort List

LeetCode之Sort List 时间复杂度为O(n log n),空间复杂度为常量的单链表排序算法
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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