java各种排序算法

/**
	1.直接插入排序
		算法思想：将第n个数插入到前n个已经排好序的数组当中，这种排序方式适合n的数字不太大的情况，并且数组基本有序。
			时间复杂度O(n2);
*/
	public static void  InsertSort(int a[]){
		if(a==null || a.length==0) return;
		for(int i=1;i<a.length;i++){
			int j=i-1;
			int temp=a[i];
			while(j>=0&&j<=a.length-1&&a[j]>temp){
				a[j+1]=a[j];
				j--;
			}
			a[j+1]=temp;
		}
	}

	/**
		2.折半插入排序，这个排序的算法只是减少了查找的时间，时间复杂度为O(n2)
	*/

	public static void BinSort(int a[]){
		if(a==null || a.length==0) return;
			for(int i=1;i<a.length;i++){
				int low=0;
				int high=i-1;
				int temp=a[i];
				while(low<=high){
					
					int mid=(low+high)>>1;
					
					if(a[mid]>temp) high=mid-1;
					
					else low=mid+1;
				}

				for(int j=i-1;j>=low;j--){
					a[j+1]=a[j];
				}
				a[low]=temp;
			}
	}
	/**
		3.希尔排序,时间复杂度为O(n1.5),
	*/

//传特定参数的希尔排序
	public static void shellPass(int a[],int delt){
		for(int i=delt;i<a.length;i++){
			if(a[i]<a[i-delt]){
				int temp=a[i];
				int j=i-delt;
				for(;j>=0&&temp<a[j];j-=delt){
					a[j+delt]=a[j];
				}
					a[j+delt]=temp;
			}
		}
	}

	
	public static void ShellSort(int a[],int delt[]){
		if(a==null || a.length==0) return;

		for(int i=0;i<delt.length;i++){
			shellPass(a,delt[i]);
		}
	
	}
/**
	冒泡排序，时间复杂度为O(n2),
*/
public static void BubbleSort(int a[]){
	if(a==null || a.length==0) return;
	for(int i=0;i<a.length-2;i++){
		for(int j=0;j<a.length-1-i;j++){
			if(a[j+1]<a[j]){
				int temp=a[j+1];
				a[j+1]=a[j];
				a[j]=temp;
			}
		}
	}
}

/**
	快速排序，性能最差的时候，时间复杂度O(n2),但是平均性能最好
*/
public static int QuickPass(int a[],int low,int high){
	
	int flag=a[low];
	while(low<high){
		while(low<high&&flag<a[high])  high--;
		if(low<high){
			a[low]=a[high];low++;
		}
		while(low<high&&flag>a[low]) low++;
		if(low<high){
			a[high]=a[low];high--;
		}
	}
	a[low]=flag;
	return low;
}

public static void QuickSort(int a[],int low,int high){
	if(a==null || a.length==0) return;
	if(low<high){
		int pos=QuickPass(a,low,high);
		QuickSort(a,low,pos-1);
		QuickSort(a,pos+1,high);
	}

}

/**
	简单选择排序
*/

public static void SimpleSelectSort(int a[]){
	if(a==null || a.length==0) return;
	for(int i=0;i<a.length-1;i++){
		int k=i;
		for(int j=i+1;j<=a.length-1;j++){
			if(a[j]<a[k]) k=j;
		}
		if(k!=i){
			int temp=a[k]; a[k]=a[i];a[i]=temp;
		}
	}
}



/**
	堆排序，时间复杂度为O(nlogn),平均时间复杂度也是O(nlogn),适合数目不太大的排序，大是相对于快速排序数目要大得多，相对于归并排序就小了，
*/
//大堆根
public static void Sift(int a[],int low,int high){
	int i=low;
	int j=i*2+1;

	int temp=a[i];

	boolean finish=false;
	while(!finish&&j<=high){
		if(j+1<=high&&a[j+1]>a[j]){
			j=j+1;
		}
		if(temp>a[j])  finish=true;
		else{
			a[i]=a[j];
			i=j;
			j=2*i+1;
		}
	}
	a[i]=temp;
}

//建初堆
public static void Cre_Heap(int a[]){
	for(int i=(a.length-1)/2;i>=0;i--){
		Sift(a,i,a.length-1);
	}
}

//堆排序
public static void HeapSort(int a[]){
	if(a==null || a.length==0) return;
	Cre_Heap(a);
	for(int i=a.length-1;i>=1;i--){
		int temp=a[0];
		a[0]=a[i];
		a[i]=temp;
		Sift(a,0,i-1);
}
}

/**
	2路-归并排序
*/

//将a数组low-mid，和mid+1-high合并到b中
public static void Merge(int a[],int low,int mid,int high,int b[]){
	int i=low,j=mid+1,k=low;
	while((i<=mid)&&(j<=high)){
			if(a[i]<=a[j]){
				b[k]=a[i];
				i++;
			}
			else{
				b[k]=a[j];
				j++;
			}
		k++;
	}
		while(i<=mid){
			b[k]=a[i];
			i++;k++;
		}
		while(j<=high){
			b[k]=a[j];
			k++;j++;
		}
	}
//通过递归调用实现不断的合并最后达到排序的目的
	public static void MergeSort(int a[],int low,int high,int c[]){
		if(a==null || a.length==0) return;
		int b[]=new int[a.length];
		if(low==high) c[low]=a[low];
		else{
			int mid=(low+high)>>1;
			MergeSort(a,0,mid,b);
			MergeSort(a,mid+1,high,b);
			Merge(b,0,mid,high,c);
		}

	}
}

排序方法的稳定性，  简单排序中只有“简答选择排序”是不稳定的，性能好的排序 有“快速排序”，"希尔排序"，"堆排序"，"归并排序"，"基数排序"，其中“快速排序”，"希尔排序"，"堆排序"是不稳定的排序，  当数量级较小的时候，可以使用简单排序，当序列基本有序的时候，“直接插入排序”性能较好，当数量较大，但是移动次数较少的时候，可以使用“简单选择排序”，“快速排序”的平均性能是性能好的排序方法里面性能最好的，但是“快速排序”的最差性能达到O(n2), ”希尔排序“是对“直接插入排序”的改进，直接插入排序是在序列基本有序的时候，性能较高，”希尔排序“当参数为1的时候就是“直接插入排序”，“堆排序”是对树形排序的改进，树形排序需要额外的n-1个存储空间，堆排序则优化了需要O(1)辅存，“堆排序”的平均时间复杂度，最坏时间复杂度都是O(nlogn),但是当n较大的时候，其性能不及“归并排序”，“归并排序”的最坏时间复杂度和平均时间复杂度也是O(nlogn),但是由于要附加和待排序列等数量的空间，所以很少用到内部排序，一般用在外部排序中，“基数排序”采用“低位优先”的排序策略，通过反复进行分配和收集，完成排序，“基数排序”的最坏时间复杂度和平均时间复杂度都是O(dn)，其中d是数字的位数。要用的辅助存储是O(rd),其中rd是各位数字的取值范围。

综上所述，所有的排序方法都存在优缺点，在选取排序算法的时候，一般要把多种排序算法结合起来一起使用，达到效率的最佳。