七大排序java实现

package 七大排序;

public class Heapsort {
	public static void main(String[] args) {
		int a[]={5,4,9,8,7,6,0,1,3,2,1};
		//int[] b={5,4,9,8,7,6,0,1,3,2};数组初始化的两种等价的方式
		
		//七大排序
		heapsort(a);
		//bublesort(a);
		//mergesort(a);
		//quiksort(a,0,a.length-1);
		//selectsort(a);
		//insertsort(a);
		//shellsort(a);
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+" ");
		}
	}
	//三个比较简单的排序，排序最近每天写一遍，瞬间手写出来，在面试的时候
	
	//直接插入排序
	public static void insertsort(int[] a){
		for(int i=1;i<a.length;i++){
			int temp=a[i];
			int j=0;
			
			//核心算法位置,操作难点
			for(j=i-1;j>=0&&a[j]>temp;j--){
				a[j+1]=a[j];
			}
			a[j+1]=temp;
		}
	}
	//希尔排序，插入排序的变式,代码复杂一点
	public static void shellsort(int[] a){
		int gap=a.length/2;
		int j=0;
		while(gap>=1){//步长临界值，循环结束的标志，当步长为1之后，希尔排序的数列有序，满足我们的要求
		for(int i=gap;i<a.length;i++){
			int temp=a[i];//从步长位置向后移动
			
			//核心算法理解
			for(j=i-gap;j>=0;j=j-gap){
				if(a[j]>temp){
					a[i]=a[j];
				}else{
					break;
				}
			}
			a[j+gap]=temp;//难点：将减去的gap加上去，实现位置的交换
		}
		gap=gap/2;
		}
	}
	//选择排序
	public static void selectsort(int[] a){
		for(int i=0;i<a.length-1;i++){//注意边界条件，易错点
			int n=i;
			for(int j=i+1;j<a.length;j++){//条件起点是从第二个开始j=i+1
				if(a[j]<a[n]){//易错点！！！这里是，找到后面的最小值，不要错误的用a[i]，导致出错，依次向下找
					n=j;
				}
			}
			if(a[n]!=a[i]){//交换条件比较好，防止出现相等的情况
				int temp=a[n];
				a[n]=a[i];
				a[i]=temp;
			}
		}
	}
	
	
	//归并
	public static void mergesort(int[] a){
		int mid=a.length/2;
		//拆分数组，直至都是一个
		if(a.length>1){//数组拆分递归结束的条件是都是单个元素时
			
			int[] a1=new int[mid];
			System.arraycopy(a, 0, a1, 0, mid);//注意边界，数组拷贝时，不包括mid位置的值，只是0--(mid-1)，其中五个变量的位置和依据是重点
			mergesort(a1);//接着进行拆分
			
			int[] a2=new int[a.length-mid];
			System.arraycopy(a, mid, a2, 0, a.length-mid);
			mergesort(a2);
			
			int[] temp=mergearr(a1,a2);
			System.arraycopy(temp, 0, a, 0, a.length);
			
		}

		
	}
	
	public static int[] mergearr(int[] a1,int[] a2){
		int[] temp=new int[a1.length+a2.length];
		
		//以下是三个数组的索引,用于操作后面的三个数组，比较经典
		int c1=0;
		int c2=0;
		int c3=0;
		
		//排列两个有序的数组的核心算法,while 配合++ --代替for循环变得比较简单，尤其是一些逼近算法中常用
		while(c1<a1.length&&c2<a2.length){
			if(a1[c1]<a2[c2]){
				temp[c3++]=a1[c1++];
			}else{
				temp[c3++]=a2[c2++];
			}
		}
		
		while(c1<a1.length){
			temp[c3++]=a1[c1++];
		}
		
		while(c2<a2.length){
			temp[c3++]=a2[c2++];
		}
		
		return temp;
	}
	
	//快排
	public static void quiksort(int[] a,int low,int high){
		
		//没有下面的条件栈会溢出
		if(low>=high){
			return;//递归结束的条件
		}
		
		int temp=a[low];
		int i=low;
		int j=high;
		
		//核心代码区
		while(i<j){
		while(a[j]>=temp&&i<j){
			j--;
		}
		if(i<j){
		a[i++]=a[j];
		}
		while(a[i]<temp&&i<j){
			i++;
		}
		if(i<j){//没有这个条件会错过i的正确位置，可能会跑到对边上去
		a[j--]=a[i];
		}
		
		}
		a[i]=temp;
		quiksort(a,low,i-1);
		quiksort(a,i+1,high);
		
	}
	
	//冒泡排序
	public static void bublesort(int[] a){
		int temp=0;
		boolean flag=true;//用于优化算法，避免不必要的冒泡，告别简单粗暴
		
		for(int k=1;k<a.length&&flag;k++){//最差的情况是冒泡a.length-1次
			flag=false;
			for(int i=0;i<a.length-k;i++){
				if(a[i]>a[i+1]){
					temp=a[i];
					a[i]=a[i+1];
					a[i+1]=temp;
					flag=true;
				}
			}
		}
	}
	
	//堆排序优化算法如下，将根节点的编号为1，但是在数组中的存储为0的位置，这种错位在程序设计中务必要-1当调整数组元素的时候
	public static void heapsort(int[] a){
		int i;
		int len=a.length;
		
		//创建堆
		for(i=len/2;i>0;i--){
			adjustheap(a,i,len);
		}
		
		//建堆之后开头的最大值与最后一个元素对调，之后再调整
		for(i=len;i>0;i--){
			int temp=a[0];
			a[0]=a[i-1];
			a[i-1]=temp;
			adjustheap(a,1,i-1);//再次调整堆的时候，只需要考虑对调过去的根节点即可
			
		}
	}
	
	//调整堆是堆排序的核心算法部分
	public static void adjustheap(int[] a,int n,int len){

		int left=2*n;
		int right=2*n+1;
		int max=n;
		
		if(left<=len&&a[left-1]>a[max-1]){
			max=left;
		}
		
		if(right<=len&&a[right-1]>a[max-1]){
			max=right;
		}
		
		if(max!=n){
			int temp=a[n-1];
			a[n-1]=a[max-1];
			a[max-1]=temp;
			adjustheap(a,max,len);
		}
		
	}

}