LeedCode：Sort List

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

一、快速排序

ListNode* sortList(ListNode* head)
{
	if(head == NULL)
		return head;
	ListNode* end = head;
	while(end ->next != NULL)
		end = end->next;
	QuickSort(head,end);
	return head;
}

void QuickSort(ListNode* begin,ListNode* end)
{
	if(begin != end)
	{
		ListNode* intermedia = partition(begin,end);
		if(intermedia != begin)
		{
			ListNode* temp = begin;
			while(temp->next != intermedia)
				temp = temp->next;
			QuickSort(begin,temp);

		}
		if(intermedia != end)
			QuickSort(intermedia->next,end);
	}
}

ListNode* partition(ListNode* begin , ListNode* end)
{
	int val = end->val;
	ListNode* pIntermedia = begin;
	ListNode* pTemp = begin;
	while(pTemp != end )
	{
		if(pTemp->val <= val)
		{
			int temp = pIntermedia->val;
			pIntermedia->val = pTemp->val;
			pTemp->val = temp;
			pIntermedia = pIntermedia->next;
		}
		pTemp=pTemp->next;		
	}
	int temp = pIntermedia->val;
	pIntermedia->val = end->val;
	end->val = temp;
	
	return pIntermedia;
}

无法AC 超时

二、归并排序

ListNode* sortList(ListNode* head)
{
	if(!head || !head->next)
		return head;	
	return mergeSort(head);
}

ListNode* mergeSort(ListNode* begin)
{
	if(!begin || !begin->next)
		return begin;
	ListNode* intermedia = begin;
	ListNode* pre = NULL;
	ListNode* temp = begin;
	while(temp && temp->next != NULL)
	{
		temp = temp->next->next;
		pre = intermedia;
		intermedia = intermedia->next;
	}
	pre->next = NULL;
	ListNode *lhalf=mergeSort(begin);  
    ListNode *rhalf=mergeSort(intermedia);

	return merge(lhalf,rhalf);
}
ListNode* merge(ListNode* lh,ListNode* rh)
{
	
	ListNode* result = new ListNode(0);
	ListNode* current = result;
	while(lh && rh)
	{
		if(lh->val <= rh->val)
		{
			current->next = lh;
			lh = lh->next;
		}
		else
		{
			current->next = rh;
			rh = rh->next;
		}
		current = current->next;
	}
	if(lh)
		current->next = lh;
	else
		current->next = rh;
	current = result->next;
	result->next = NULL;
	delete result;

	return current;
}

AC  264ms