排序算法（4）---归并排序&总结

归并排序

 定义

    归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

思想

     采用分治法思想 ，现将大问题进行分解，分解成小问题，再依次对小问题进行归并（归并的前提是两段子序列有序），最后求得整体的解。

算法描述    

    归并操作的工作原理如下：

        第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

        第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置

        第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

        重复步骤3直到某一指针超出序列尾

        将另一序列剩下的所有元素直接复制到合并序列尾

图解

实现

void _MergeSort(int* a, int left, int right, int* tmp)//tmp为临时空间
{
	if(left >= right) //先判断区间是否有效
	{
		return ; 
	}

	int mid = left+((right-left)>>1);
	//[left,mid] [mid+1,right]
	
	_MergeSort(a,left,mid,tmp);
	_MergeSort(a,mid+1,right,tmp);


	//归并
	int index = left;
	int begin1 = left,end1 = mid;
	int begin2 = mid+1,end2 = right;

	while(begin1<=end1 && begin2 <= end2)
	{
		if(a[begin1] < a[begin2])
		{
			tmp[index++] = a[begin1++];
		}
		else
		{
			tmp[index++] = a[begin2++];
		}
	}

	//拷贝begin1或begin2后面元素
	while(begin1 <= end1)
	{
		tmp[index++] = a[begin1++];
	}

	while(begin2 <= end2)
	{
		tmp[index++] = a[begin2++];
	}

	//拷回原数组
	index = left;
	while(index <= right)
	{
		a[index] = tmp[index];
		index++;
	}
}

void MergeSort(int* a, int n)
{
	assert(a);

	int *tmp = new int[n];
	_MergeSort(a,0,n-1,tmp);
	delete[] tmp; //开辟空间不要忘记释放
}

分析

 

    时间复杂度：O(nlogn)

    空间复杂度：O(n)

// 需要开辟一段临时空间保存已定排序好的数，所以时间复杂为O(n).

注：归并（严格的二分）时间复杂度略好于快排（依赖于key）,但有空间的消耗。

 

    这里分析一道题目，对链表进行排序，要求时间复杂为O(nlogn)，空间复杂为O(1)

    

   分析：首先对于时间复杂度要求为O(nlogn),我们首先想到的是快排和归并，但快排的平均时间复杂度均为O(nlogn),可想这里应该使用归并，由于链表进行排序，这里可减少空间的开辟。

    

          方法：先对链表进行划分，在对两个有序链表进行合并

          实现：    

ListNode* MergeSort(ListNode* l1,ListNode* l2)
{
	ListNode* newhead = new ListNode(0);
	ListNode* tail = newhead;

	while(l1 && l2)
	{
		if(l1->val < l2->val)
		{
			tail->next = l1;
			tail = l1;
			l1 = l1->next;
		}
		else
		{
			tail->next = l2;
			tail = l2;
			l2 = l2->next;
		}
	}

	while(l1)
	{
		tail->next = l1;
		tail = l1;
		l1 = l1->next;
	}

	while(l2)
	{
		tail->next = l2;
		tail = l2;
		l2 = l2->next;
	}

	return newhead->next;
}

ListNode *sortList(ListNode *head) 
{
	if(head == NULL || head->next == NULL)
	{
		return head;
	}

	ListNode* slow = head;
	ListNode* fast = head;
	while(fast->next && fast->next->next)
	{
		slow = slow->next;
		fast = fast->next->next;
	}
	//若只有两个节点时，fast == head ;会产生死循环，所以应该使fast = slow->next 
	fast = slow ->next; 
	slow->next = NULL;
	
	//划分
	ListNode* l1 = sortList(head);
	ListNode* l2 = sortList(fast);
	//合并
	return MergeSort(l1,l2);
}

各排序总结