归并排序，选择排序，插入排序，高效插入排序，快速排序

本文总结了插入排序，归并排序，快速排序，选择排序4种方法，思路清晰，简单明了。

插入排序

特点：稳定，时间复杂度 O(n^2)

原理：以数组首端为已排序好的数列（虽然只有一个），从数组首端地址之后的待排序数组成员找到已经排序好的数列的插入位置，将待排序成员插入该位置，位置之后的成员依次往后移一位。

归并排序

特点：稳定，时间复杂度 O(nlog n)

原理：归，递归之意，并，合并之意，归：利用递归思路，分隔数组为2部分数组，不断递归，最终实际上得到只含有1个成员的数组，完成排序；归：假如两个数组均排好序，采用两指针对比大小，将两数组合并。

快速排序

特点：不稳定，时间复杂度 最理想 O(nlogn) 最差时间O(n^2)

原理：确定基准变量，从待排序数组选择大于和小于基准变量的成员，交换两成员位置，同时把基准变量放置于两成员之间，这样既可保证得到一个：小于基准变量，基准变量，大于基准变量的序列；利用递归进行循环，既可快速排序。

选择排序

特点：不稳定，时间复杂度 O(n^2)

原理：先选择整个数列的最大或最小值，放置于数组首端，去除该数字，再选择最大或最小值，放置于数组首端之后，依次循环。

程序输入：一组数值，数值之间空格，回车结束输入

程序输出：各类排序结果由小到大输出

sample input： 56 23 1 4 6

sample output： 1 4 6 23 56

#include <iostream>
using namespace std;
int result[1000];
		
void mergearray(int a[],int first,int mid ,int last)
{	
	int i,j,k,n,m;
	i=first;
	n=mid;
	j=mid+1;
	m=last;
	k=0;
	while(i<=n && j<=m)
	{
		if(a[i]<a[j])
		{
		result[k++]=a[i++];
		}
		else
		{
		result[k++]=a[j++];
		}
	}

	while(i<=n)
	{	
		result[k++]=a[i++];
	}
	while(j<=m)
	{	
		result[k++]=a[j++];
	}

	k=0;
	i=0;
	while(first+i<=last)
	{
		a[first+i]=result[k++];
		i++;
	}
}


void merge(int arr[],int first,int last)
{
	int mid=(first+last)/2;
	if(first<last)
	{
		merge(arr,first,mid);
		merge(arr,mid+1,last);
		mergearray(arr,first,mid,last);
	}

}

void choose(int arr[],int first,int last)
{
	for(int i=first;i<last;i++)
		for(int j=i+1;j<=last;j++)
			if(arr[j]<arr[i])
			{
				int temp=arr[i];
				arr[i]=arr[j];
				arr[j]=temp;
			}
}

void insert(int arr[],int first,int last)
{
	for(int i=first+1;i<=last;i++)
	{
		int tag=i;
		for(int j=i-1;j>=first;j--)
			if(arr[j]>arr[i])
			{
				tag=j;
			}

		if(tag!=i)
		{
			int temp=arr[i];
			for(int w=i-1;w>=tag;w--)
			arr[w+1]=arr[w];
		arr[tag]=temp;
		}
	}
}

void inserthigh(int arr[],int first,int last)
{
	for(int i=first+1;i<=last;i++)
	{
		int tempnum=i;
		for(int j=i-1;j>=first;j--)
			if(arr[j]>arr[tempnum])
			{
				int temp=arr[tempnum];
				arr[tempnum]=arr[j];
				arr[j]=temp;
				tempnum=j;
			}	
	}
}

void quicksort(int arr[],int first,int last)
{		
	int leftpoint=first;
	int rightpoint=last;
	int base=arr[first];
	int temp=0;
	if(leftpoint>=rightpoint)
		return;
			
	while(leftpoint!=rightpoint)
	{
		while(arr[rightpoint]>=base && leftpoint<rightpoint )
		rightpoint--;
		while(arr[leftpoint]<=base && leftpoint<rightpoint)
		leftpoint++;

		if(leftpoint<rightpoint)
		{			
		temp=arr[rightpoint+1];
		arr[leftpoint+1]=arr[rightpoint+1];
		arr[rightpoint+1]=temp;
		}
	}

	int middle=(leftpoint+leftpoint)/2;
	arr[first]=arr[middle];
	arr[middle]=base;

	quicksort(arr,first,middle);
	quicksort(arr,middle+1,last);

}

int main()
{
	int array[1000];
	int casenum=0;
	int arraynum=0;

	while(cin>>array[arraynum] )
	{
	arraynum++;
	if(getchar() == '\n') break;
	}

	cout<<"排序前数组为：   "<<endl;
	for(int i=0;i<arraynum;i++)
		cout<<array[i]<<" ";
	
	cout<<endl<<"请选择排序方法（0-归并排序，1-选择排序，2-插入排序，3-高效插入排序，4-快速排序）："<<endl;
	cin>>casenum;
	switch(casenum)
	{
	case 0: merge(array,0,arraynum-1);
			cout<<endl<<"归并排序结果："<<endl;
			break;
	case 1: choose(array,0,arraynum-1);
			cout<<endl<<"归并排序结果："<<endl;
			break;
	case 2:	insert(array,0,arraynum-1);
			cout<<endl<<"插入排序结果："<<endl;
			break;
	case 3:	inserthigh(array,0,arraynum-1);
			cout<<endl<<"高效插入排序结果："<<endl;
			break;
	case 4:	quicksort(array,0,arraynum-1);
			cout<<endl<<"快速排序结果："<<endl;
			break;
	default:	cout<<endl<<"您的输入有误，排序失败，原结果为："<<endl;	
	}
	
	for(int i=0;i<arraynum;i++)
		cout<<array[i]<<" ";

	int pause;
	cin>>pause;
	return 1;
}