分治法

//伪代码描述
type temp[n];                       //这可能是该算法唯一不足的地方，就是它的空间复杂度是O(N)
MergeSort(type num[n],int start,int end)//排序算法
{
    int mid = (start + end) / 2;    //中间位置
    MergeSort(num[n],start,mid);    //对前半部分子序列进行归并排序
    MergeSort(num[n],mid+1,end);    //对后半部分子序列进行归并排序
    Merge(num,start,mid,end,temp);  //这一步进行合并操作
}
Merge(num,start,mid,end,temp)//合并操作
{
    i = start,j = mid + 1, k = start;
    //这里使用的办法可以称之为“双指针法”。在这里分别是i和j。它们分别指向了待合并的两个子序列的
    //第一个元素，然后比较这两个元素的大小(我在这里排序的结果是从小到大的),将小的那个元素放到
    //备用数组中。然后被复制的那个数组的指针后移，继续比较，直到某一子序列全部比较完毕。
    while(i < mid && j < end)
    {
        if (num[i] <= num[j])    temp[k++] = num[i++]; 
		else    temp[k++] = num[j++];
			
    }
    //将未处理的剩余元素，直接复制到备用数组temp中。
    if(i < mid)    copy temp[k++] = num[i++];
    else           copy temp[k++] = num[j++];
}

#include <iostream>
int num[10] = { 2,3,1,5,7,6,8,0,9,4 };	//待排序数组
int temp[10];	//备用数组
using std::cout;
void MergeSort(int *num, int start, int end);
void Merge(int * num, int start, int mid, int end);
int main()
{
	MergeSort(num, 0, 9);
	for (int i = 0; i < 10; i++)
	{
		cout << num[i] << std::endl;
	}
	system("pause");
}

void MergeSort(int * num, int start, int end)
{
	int mid = (start + end) / 2;
	if (start < end)
	{
		MergeSort(num, start, mid);
		MergeSort(num, mid + 1, end);
		Merge(num, start, mid, end);
	}
}

void Merge(int * num, int start, int mid, int end)
{
	int i, j, k;
	i = start;
	j = mid + 1;
	for (k = start; i <= mid && j <= end ; k++)
	{
		if (num[i] <= num[j])
		{
			temp[k] = num[i++];
		}
		else
		{
			temp[k] = num[j++];
		}
	}
	while (i <= mid)
	{
		temp[k++] = num[i++];
	}
	while (j <= end)
	{
		temp[k++] = num[j++];
	}
	for (int i = start; i <= end; i++)	//将temp中的数据拷贝回num中
	{
		num[i] = temp[i];
	}
}

#include <iostream>
void QuickSort(int *num,int start,int end);
void swap(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}
int main()
{
	int num[10] = { 2, 4, 1, 3, 5, 9, 0, 6, 7, 8 };
	QuickSort(num, 0, 9);
	for (int i = 0; i < 10; i++)
	{
		std::cout << num[i] << std::endl;
	}
	system("pause");
}

void QuickSort(int * num, int start, int end)
{
	if (start >= end)
	{
		return;
	}
	int k = num[start];        //代码这里实际是用k表示的
	int i = start;
	int j = end;
	while (i != j)
	{
		while (j > i && k <= num[j])    //偶数次的时候移动j.
		{
			j--;
		}
		swap(num[i], num[j]);
		while (i < j && k >= num[i])    //奇数次的时候移动i.
		{
			i++;
		}
		swap(num[i], num[j]);
	}
	QuickSort(num, start, i - 1);
	QuickSort(num, i + 1, end);
}

#include <iostream>
using std::cout;
using std::cin;

void Mfun(int *num, int m, int start, int end);
void QuickSort(int * num, int start, int end);
void swap(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}
int count = 0;
int main()
{
	int num[10] = { 3,4,2,1,5,6,0,8,7,9 };
	int m;
	cout << "请输入m:";
	cin >> m;
	Mfun(num, m, 0, 9);
	QuickSort(num, 10 - m, 9);
	for (int i = 9; i > 9 - m ; i--)
	{
		cout << num[i] << std::endl;
	}
	system("pause");
}
void Mfun(int *num, int m, int start, int end)
{
	if (m < end - start + 1)	
	{
		int i = start;
		int j = end;
		int k = num[start];
		while (i != j)
		{
			while (j > i && num[j] >= k)
			{
				j--;
			}
			swap(num[i], num[j]);
			while (i < j && num[i] <= k)
			{
				i++;
			}
			swap(num[i], num[j]);
		}
		Mfun(num, m, i + 1, end);
	}
	if (m > end - start + 1)
	{
		m = m -(end - start + 1);
		Mfun(num, m, start - m, start - 1);
	}
}
void QuickSort(int * num, int start, int end)
{
	if (start >= end)
	{
		return;
	}
	int k = num[start];        //代码这里实际是用k表示的
	int i = start;
	int j = end;
	while (i != j)
	{

		while (j > i && k <= num[j])    //偶数次的时候移动j.
		{
			j--;
		}
		swap(num[i], num[j]);
		while (i < j && k >= num[i])    //奇数次的时候移动i.
		{
			i++;
		}
		swap(num[i], num[j]);
	}
	QuickSort(num, start, i - 1);
	QuickSort(num, i + 1, end);
}