内部排序小结

一、插入类排序：
1、直接插入排序：

void InsertSort(int *Data,int size)
{
	for(int i=1;i<size;++i){//从第二个元素开始依次插入 
		int j=i-1;//从当前的前一个位置开始往前查找插入位置 
		int temp=Data[i];//暂存要插入的值，避免被覆盖 
		while(j>=0){
			if(temp<Data[j]){
				Data[j+1]=Data[j];//元素后移 
				j--;//继续往前查找 
			}else break;//找到位置 
		}
		Data[j+1]=temp;//插入 
	}
}

2、折半插入排序：

void HalfInsertSort(int *Data,int size)
{
	for(int i=1;i<size;++i){//从第二个元素开始依次插入 
		int mid;//中间位置 
		int low=0,high=i-1;//插入的区间 
		int temp=Data[i];//暂存当前值，避免覆盖 
		while(1){
			mid=(low+high)/2;
			if(temp>=Data[mid]) low=mid+1;
			else if(temp<Data[mid]) high=mid-1;
			if(low>high) break;//找到位置 
		}
		for(int k=i-1;k>=low;--k) Data[k+1]=Data[k];//元素统一后移
		Data[low]=temp;//插入 
	}
}

3、希尔排序：

void ShellSort(int *Data,int size)
{
	for(int gap=size/2;gap>=1;gap=gap/2)//缩小增量 
    	//直接插入排序
	    for(int i=gap;i<size;++i){//从第gap+1个元素开始依次插入 
	    	int temp=Data[i];//暂存 
	    	int j=i-gap;//从当前组的前一个位置开始往前查找 
	    	while(j>=0){
	    		if(temp<Data[j]){
	    			Data[j+gap]=Data[j];//元素后移 
		    		j-=gap;//继续往前查找 
	    		}else break;//找到位置 
	    	}
		    Data[j+gap]=temp;//插入 
	    }
}

二、交换类排序：
1、冒泡排序：

void BubbleSort(int *Data,int size)
{
	for(int i=0;i<size-1;++i)
		for(int j=0;j<size-i-1;++j)
			if(Data[j]>Data[j+1])
				swap(Data[j+1],Data[j]);
}

2、梳排序：

void CombSort(int *Data,int size)
{
	for(int gap=size/1.3;gap>=1;gap/=1.3)
		for(int j=0;j+gap<size;++j)
			if(Data[j]>Data[j+gap])
				swap(Data[j],Data[j+gap]);
}

3、快速排序：

void QuickSort(int *Data,int low,int high)
{
	int i=low,j=high;
	int mid=Data[(i+j)/2];
	while(i<=j){
		for(;Data[i]<mid;++i);//从左边找到第一个比mid大的
	    for(;Data[j]>mid;--j);//从右边找到第一个比mid小的
	    if(i<=j) swap(Data[i++],Data[j--]);
	}
	if(i<high) QuickSort(Data,i,high);
	if(j>low) QuickSort(Data,low,j);
}

三、选择类排序：
1、简单选择排序：

void SelectSort(int *Data,int size)
{
	//为每个位置选择合适元素 
	for(int i=0;i<size-1;++i){
		int min_id=i;
		for(int j=i+1;j<size;++j)
			if(Data[j]<Data[min_id])
				min_id=j;
		if(min_id!=i) swap(Data[i],Data[min_id]);
	}
}

2、堆排序：

void AdjustHeap_Down(int *Data,int start,int end)
{
	//为start处的元素选择合适位置（运用了插入排序思想） 
	int temp=Data[start];//暂存 
	for(int i=2*start+1;i<=end;i=2*i+1){
		if(i+1<=end&&Data[i+1]>Data[i]) i++;//找到左右孩子中大的那个 
		if(Data[i]>temp){
			Data[start]=Data[i];//元素上移 
			start=i;
		}else break;
	}
	Data[start]=temp;
}

void HeapSort(int *Data,int size)
{
	//建堆 
	for(int i=size/2-1;i>=0;--i)
	    AdjustHeap_Down(Data,i,size-1);
	//交换调整
	for(int i=size-1;i>0;--i){
		swap(Data[0],Data[i]);
		AdjustHeap_Down(Data,0,i-2);
	}
}

四、二路归并排序：

void Merge(int *Data,int low,int mid,int high)
{
	//temp暂存low到high的元素 
	int *temp=(int*)malloc(sizeof(int)*(high-low+1));
	for(int i=low;i<=high;++i)
	    temp[i-low]=Data[i];
	//更新mid与high契合temp
	mid=mid-low;
	high=high-low;
	//两条路的指示 
	int i=0,j=mid+1;
	//归并 
	while(i<=mid&&j<=high){
		if(temp[i]<temp[j]) Data[low++]=temp[i++];
		else Data[low++]=temp[j++];
	}
	//把剩余元素连接到尾部 
	for(;i<=mid;) Data[low++]=temp[i++];
	for(;j<=high;) Data[low++]=temp[j++];
	free(temp);
}

void MergeSort(int *Data,int low,int high)
{
	if(low<high){
		int mid=(low+high)/2;
		MergeSort(Data,low,mid);//排序前半部分 
		MergeSort(Data,mid+1,high);//排序后半部分 
		Merge(Data,low,mid,high);//归并两部分 
	}
}