内部排序-插入排序

/**
 *
 *	Coder: LinX  2017-7-18 - 2017-7-21 
 *
 *	内容: 插入类排序 
 *
 */ 
 
 void insertSort(int *a,int len);		//插入排序 
 
 void shellSort(int *a,int len);		//希尔排序 
 
 void halfFindSort(int *a,int len);		//折半查找排序 
 
 void print(int *a,int len);
 
 int findPos(int *a,int low,int high,int value);		
 
 int main()
 {
 	
	int a[10]={1,9,8,7,6,5,4,3,2,6};
 	
 	shellSort(a,10);
 	
 	print(a,10);
 	
 	return 0;
 	
 } 

 /*插入排序*/
 
 //复杂度分析: 这是最简单的插入排序，但这是其他插入排序的基础，因为折半插入排序只是使用
 
 //折半查找直接找出插入的位置，然后交换；而希尔排序在最后也要执行一次直接插入排序 
 
 //对于直接插入分析，除了第一个元素 i=2....n 依次向后要与前面元素比较并移动i次(这个是最
 
 //差的情况，即完全逆序)因此每一轮为1+2+...+(n-1)=n(n+1)/2 次，总共是（n-1）轮因此复杂度
 
 //为O(n^2)   最好的情况：每一轮只需比较一次并且不需要移动，O(n) 
 
 void insertSort(int *a,int len)
 {
 	
 	int i,j,temp;
 	
	//这个代码时间复杂度太高 （自己写的）
	 
	//思路: 每次将当前元素都与前面已将排好序的元素比较直到找到比当前元素小的然后移动插入到
	 
	//这个元素的前面  这种方法太过于低效，其实可以这样想：将当前元素与前面排好序的最后一个元素比较
	 
	//在找到比当前元素小的元素之前，边比较边移动元素，这样就省去了前面方法中两次for循环寻找位置和插入
	 
 	/*for(i=1;i<len;i++)
 	{
 		
 		for(j=0;j<index;j++)
 		{
 			
 			if(a[i]<a[j])
 			{
 			
 				temp=a[i];
 				
 				for(k=i;k>j;k--)
 				{
 					
 					a[k]=a[k-1];
 				
 				}
 			
 				a[j]=temp;
 				
 				break;
 			
 			}
 			
 		}
 		
 		index++;
 		
 	}*/
	 
	 
	 //插入排序的核心就是边比较边移动当前未被排序的元素 
	 
	 for(i=1;i<len;i++)
	 {
	 	
	 	j=i-1;
	 	
	 	temp=a[i];
	 	
	 	//核心代码，边比较边移动 
	 	while(j>=0&&a[j]>temp)
	 	{
	 		
	 		a[j+1]=a[j];
			 
			j--;	
	 		
	 	}
	 	
	 	a[j+1]=temp;
	 	
	 } 
 	
 }
 
 
 //折半查找相当于对直接插入排序的一种优化，因为插入排序在每次找到当前元素应该在有序序列
 
 //当中的位置的时候都要依次与有序序列从右往左依次比较，效率很低（O(n)），因此对于这个弱点，可以
 
 //用折半查找优化（O(logn)），
 
 /*折半查找排序*/
 
 void halfFindSort(int *a,int len)
 {
 	
 	int i,pos,j,value,temp,low,high,mid;
 	
 	for(i=1;i<len;i++)
 	{
 		
 		temp=a[i];
		 	
 		j=i-1;
 		
 		if(a[j]>temp)
 		{
 			
 			/*递归代码折半查找要插入的位置*/
			  
	 		/*pos=findPos(a,0,j,temp);
	 			
	 		for(j=i;j>pos+1;j--)
	 		{
	 		
	 			a[j]=a[j-1];
	 			
	 		}
	 	
	 		a[pos+1]=temp;*/ 
	 		
	 		//非递归折半查找
			 
			low=0,high=j;
			 
			while(low<=high)
			{
				
				mid=(low+high)/2;
				
				if(temp<a[mid])
				{
					
					high=mid-1;
					
				}
				
				else
				{
					
					low=mid+1;
					
				}
				
			}
			
			
			for(j=i;j>high+1;j--)
	 		{
	 		
	 			a[j]=a[j-1];
	 			
	 		}
	 	
	 		a[high+1]=temp;
			
	 		
	 	}
	 	
	 	//print(a,10);
 		
 	}
 	
 	
 }
 
 
 //寻找插入的位置
  
 int findPos(int *a,int low,int high,int value)
 {
 	
 	int mid=(low+high)/2;
 	
 	//这里属于细节 记住 
	  
 	if(low<=high)
 	{
 		
		 if(value<a[mid])
		 {
		 	
		 	findPos(a,low,mid-1,value);
		 	
		 }	
		 
		 else
		 {
		 	
		 	findPos(a,mid+1,high,value);
		 	
		 }
 		
 	}
 	
 	else
 	{
 		
 		printf("%d\n",high);
 		
 		//为什么返回high？ 将代码举个例子就可以了
		  
 		return high;
 		
 	}
 	
 }
 
 
 /*希尔排序*/ 
  
 void shellSort(int *a,int len)
 {
 	
 	int i,j,gap,temp;
 	
 	for(gap=len/2;gap>0;gap=gap/2)
 	{
 		
 		for(i=gap;i<len;i++)
		{
		 	
		 	j=i;
		 	
		 	//理解为j从gap后的元素开始，与前面距离为gap的元素相比较，交换完之后j向后推一个，以此类推 
		 	
			while(j>=gap&&a[j]<a[j-gap])
			{
				
				temp=a[j];
				
				a[j]=a[j-gap];
				
				a[j-gap]=temp;
				
				j=j-gap;
				
			}
		 	
		} 
 		
 	}
 	
 }
 
 void print(int *a,int len)
 {
 	
 	int i;
 	
 	for(i=0;i<len;i++)
 	{
 		
 		printf("%d ",a[i]);
 		
 	}
 	
 }