首页 > ACM题库 > LeetCode > LeetCode-Sort List 链表排序
2014
07-18

LeetCode-Sort List 链表排序

Sort List

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

原题链接: http://oj.leetcode.com/problems/sort-list/

对链表进行排序,要求的时间复杂度为O(n log n)。nlogn的排序有快速排序、归并排序、堆排序。双向链表用快排比较适合,堆排序也可以用于链表,单向链表适合用归并排序。题目要求的是常数的空间复杂度,因为这里用了递归,如果算上栈空间的话,也要 o(logn)的复杂度。

关于链表的划分,这里使用了快慢指针,从中间节点进行切开成单独的链表。在merge之后又会合并成一个链表。

以下分别用归并排序和快速排序实现(Java),遗憾的是快速排序的实现超时了,毕竟交换数据的次数过多,没有归并排序之家更换指针要快。快速排序的实现大家可以忽略,代码写的不太好。

关于链表的归并排序可参考之前的一篇文章归并排序对链表进行排序

,只是实现比下面这个有些复杂。

1. 归并排序实现

public class MergetSortList {

	public static  ListNode sortList(ListNode head) {
	    if(head == null || head.next == null) return head;
		ListNode slow = head;
		ListNode fast = head;
		//用快慢指针找到中间节点
	    while(fast.next != null && fast.next.next != null){
	    	slow = slow.next;
	    	fast = fast.next.next;
	    }
	    ListNode list2 = slow.next;
	    slow.next = null;
	    head = sortList(head);
	    list2 = sortList(list2);
    	return merge(head, list2);
	}

	private static ListNode merge(ListNode list1, ListNode list2) {
		if(list1 == null) return list2;
		if(list2 == null) return list1;
		ListNode newHead = new ListNode(0);//链表头不存储实际数据
		ListNode last = newHead;
		last = newHead;
		//连接每个节点,只更换指针,因此空间复杂度为O(1)
		while(list1 != null && list2 != null){
			if(list1.val < list2.val){
				last.next = list1;
				list1 = list1.next;
			}else{
				last.next = list2;
				list2 = list2.next;
			}
			last = last.next;
		}
		//最后剩余的部分,直接连接起来即可
		if(list1 != null) last.next = list1;
		else if(list2 != null) last.next = list2;
		return newHead.next;
	}

	public static void main(String[] args) {
		ListNode l1 = new ListNode(8);
        ListNode l2 = new ListNode(7);
        ListNode l3 = new ListNode(6);
        ListNode l4 = new ListNode(5);
        ListNode l5 = new ListNode(4);
        ListNode l6 = new ListNode(3);

    	l1.next = l2;
    	l2.next = l3;
    	l3.next = l4;
    	l4.next = l5;
    	l5.next = l6;

    	l1 = sortList(l1);

    	while(l1 != null){
    		System.out.print(l1.val + " ");
    		l1 = l1.next;
    	}
	}
}

2.快速排序实现

	//以end节点作为pivot进行划分,返回划分的节点的前一个节点
    public static ListNode partition(ListNode head, ListNode end){
		int pivot = end.val;
		ListNode lastSmallNode = null;
		ListNode tmpHead = head;
		while(tmpHead != end){
			if(tmpHead.val < pivot){
				if(lastSmallNode == null) lastSmallNode = head;
				else lastSmallNode = lastSmallNode.next;
				int tmp = lastSmallNode.val;
				lastSmallNode.val = tmpHead.val;
				tmpHead.val = tmp;
			}
			tmpHead = tmpHead.next;
		}
		//有可能是划分的节点就是第一个,此时返回null
		if(lastSmallNode == null){
			end.val = head.val;
			head.val = pivot;
			return null;
		}else{
			end.val = lastSmallNode.next.val;
			lastSmallNode.next.val = pivot;
			return lastSmallNode;
		}
	}

	public  static void quickSort(ListNode head, ListNode end){
		if( head == null || head == end || end == null || head.next == null) return;
		ListNode mid = partition(head, end);
		quickSort(head, mid);
		//空表示,划分点是第一个位置
		if(mid == null)
			quickSort(head.next, end);
		//如果划分点是最后一个位置,就无需再排序
		else if(mid != end && mid.next != null && mid.next != end)
			quickSort(mid.next.next, end);
	}

	public static  ListNode sortList(ListNode head) {
	    if(head == null || head.next == null) return head;
		ListNode tail = head;
		while(tail.next != null)
			tail = tail.next;
		quickSort(head,tail);
    	return head;
	}

  1. 为什么for循环找到的i一定是素数叻,而且约数定理说的是n=p1^a1*p2^a2*p3^a3*…*pk^ak,而你每次取余都用的是原来的m,也就是n