排序算法模板——手指记忆法

先读懂代码 ，然后多敲就完事了！

1.冒泡排序
原理：两两之间比较
//模板自己写
2.直接选择排序`
原理：两两之间比较，找最值下标

void SlectSort(int k[],int n)
{
	for(int i=0;i<n-1;i++)
	{
		int min=k[i];
		{
			for(int j=i+1;j<n;j++)
			{
				if(min>k[j])min=j;
			}
		}
		int temp=k[i];
		k[i]=k[min];
		k[min]=temp;
	}
}

3.直接插入排序（小规模性能最好）
原理：将一个记录插入到已经排好序的有序表中，从而得到一个行动，记录数增加1的有序表

void InsertSort(int k[],int n)
{
	for(int i=1;i<n;i++)
	{
		if(k[i]<k[i-1])
		{
			int temp=k[i];
			int j;
			for( j=i-1;k[j]>temp;j--)
			{
				k[j+1]=k[j];
			}
			k[j+1]=temp;
		}
	}
}

4.希尔排序（缩小增量排序）（插入排序的优化）
原理：设待排元素序列有n个元素，取一个小于n的数gap作为间隔,所有距离为gap的元素放在同一个子序列中，在每一个
子序列中分别实现直接插入排序，然后缩小间隔，重复，直到最后取gap=1.

void ShellSort(int k[],int n)
{
	int gap=n;
	do
	{
		gap=gap/3+1;
		for(int i=gap;i<n;i++)
		{
			if(k[i]<k[i-gap])
			{
				int temp=k[i];
				int j;
				for( j=i-gap;k[j]>temp;j-=gap)
				{
					k[j+gap]=k[j];
				}
					k[j+gap]=temp;
			}
		}
	}while(gap>1);
}

5.堆排序
原理：将待排序的序列构造成一个大顶堆（或小顶堆）。此时，整个序列的最大之就是堆顶的根节点。将它移走
（就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值）。

要点：根节点一定是堆中所有节点最大或者最小值，如按照层序遍历的方式给节点从1开始编号，则节点之间满足如下关系：
（大顶锥）K(i)>=K(2i) （小顶堆） K(i)<=K(2i)
K(i)>=K(2i+1) 或 K(i)<=K(2i+1)
其中（1<=i<=n/2）

void swap(int k[],int i,int j)
{
	int temp=k[i];
	k[i]=k[j];
	k[j]=temp;
}
void HeapAdjust(int k[],int s,int n)
{
	int temp=k[s];
	for(int i=2*s;i<=n;i*=2)
	{
		if(i<n&&k[i]<k[i+1])i++;
		if(temp>k[i])break;
		k[s]=k[i];
		s=i;
	}
	k[s]=temp;
}

void HeapSort(int k[],int n)
{
	for(int i=n/2;i>0;i--)
	{
		HeapAdjust(k,i,n);
	}
	
	for(int i=n;i>1;i--)
	{
		swap(k,1,i);
		HeapAdjust(k,1,i-1);
	}
}

6.快速排序
原理：每趟的排序指定一个元素作为一个基准点，把小于这个基准点的所有元素都移动到基准点左边，把大于这个基准点的所有元素都移动到基准点的右边

void swap(int k[],int low,int high)
{
	int temp=k[low];
	k[low]=k[high];
	k[high]=temp;
}
int Search(int k[],int low,int high) //找基点 
{

	int point=k[low];
	
	while(low<high)           //low<high  大前提
	{
		while(low<high&&k[high]>=point)
		{
			high--;
		}
		swap(k,low,high);
		while(low<high&&k[low]<=point)
		{
			low++;
		}
		swap(k,low,high);
	}
	return low; 
}

void Quicksort(int k[],int low,int high)
{
	int point;
	if(low<high)
	{
		point=Search(k,low,high);
		
		Quicksort(k,low,point-1);
		Quicksort(k,point+1,high);
	}
}

优化：1：优化选取基点

int Search(int k[],int low,int high) //找基点 
{
	int mid=(low+high)/2;    //优化选取基点 
	if(low<high)swap(k,low,high);
	if(mid<high)swap(k,mid,high);
	if(low<mid)swap(k,low,mid);
	
	
	int point=k[low];
	
	while(low<high)
	{
		while(low<high&&k[high]>=point)
		{
			high--;
		}
		swap(k,low,high);
		while(low<high&&k[low]<=point)
		{
			low++;
		}
		swap(k,low,high);
	}
	return low; 
}

		2：优化不必要的交换  

int Search(int k[],int low,int high) //找基点 
{
	int point=k[low];
	
	while(low<high)
	{
		while(low<high&&k[high]>=point)
		{
			high--;
		}
		//swap(k,low,high);
		k[low]=high;    //优化不必要的交点 
		while(low<high&&k[low]<=point)
		{
			low++;
		}
		//swap(k,low,high);
		k[high]=low;
	}
	return low; 
}

		3：优化小数组时的排序方法  

void InsertSort(int k[],int n)
{	
	for(int i=1;i<n;i++)
	{
		if(k[i]<k[i-1])
		{
			int temp=k[i];
			int j;
			for(j=i-1;k[j]>temp;j--)
			{
				k[j+1]=k[j];
			}
			k[j+1]=temp;
		}
	}
} 
void Quicksort(int k[],int low,int high)
{
	int point;
	if((high-low)>7)     //优化小数组时的方法  
	{
		point=Search(k,low,high);
			
		Quicksort(k,low,point-1);
		Quicksort(k,point+1,high);
	}
	else
	{
		InsertSort(k+low,high-low+1);
	}
}

		4：优化递归操作 

参考：如果一个函数中递归形式的调用出现在函数的末尾，
我们称这个递归函数是尾递归的。
当编译器检测到一个函数调用是尾递归的时候，它就覆盖当前的活跃记录而不是在栈中去创建一个新的。编译器可以做到这点，因为递归调用是当前活跃期内最后一条待执行的语句，于是当这个调用返回时栈帧中并没有其他事情可做，因此也就没有保存栈帧的必要了。通过覆盖当前的栈帧而不是在其之上重新添加一个，这样所使用的栈空间就大大缩减了。

void Quicksort(int k[],int low,int high)
{
	int point;
	while(low<high)     //优化递归操作 
	{
		point=Search(k,low,high);
		Quicksort(k,low,point-1);
		low=point+1;	
	} 
}

7.归并排序
原理：假设初始序列有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到[n/2]个长度为2或1的有序子序列；再两两归并，如此重复，直至得到一个长度为n的有序序列为止，这种排序方法称为2路归并排序。

void merging(int *list1,int list1_size,int * list2,int list2_size)
{
	int i,j,k,m;
	int temp[N];
	i=j=k=0;
	while(i<list1_size&&j<list2_size)     //两个数组的归并操作
	{
		if(list1[i]<list2[j])
		{
			temp[k++]=list1[i++];
		}
		else 
		{
			temp[k++]=list2[j++];
		}
	} 
	
	
	while(i<list1_size)					//将未归并的数组数据依次存入
	{
		temp[k++]=list1[i++];
	}
	
	
	while(j<list2_size)
	{
		temp[k++]=list2[j++];
	}
	
	
	for(m=0;m<list1_size+list2_size;m++)   
	{
		list1[m]=temp[m];        //为啥要用list1存呢？
	}
	
}

void MergeSort(int k[],int n)
{
	if(n>1)
	{
		int *list1=k;
		int list1_size=n/2;
		int *list2=k+n/2;
		int list2_size=n-list1_size;
		
		MergeSort(list1,list1_size);    
		MergeSort(list2,list2_size);	
		
		merging(list1,list1_size,list2,list2_size);	
			
	}	
} 

8.结构体排序
自己看博客去！
sort结构体排序