用java实现几种常用的排序（选择排序，冒泡排序，插入排序，希尔排序，快速排序，堆排序）

闲来无事写了几个java的排序，代码如下

package sort;

public class Sort {
    //生成含随机数的数组
	public static int[] numGenerate(int n) {
		int[] arr=new int[n];
		for(int index=0;index<n;index++) {
			arr[index]=(int)(Math.random()*n);
		}
		return arr;
	}
//	选择排序
	public static int[] ChooseSort(int[] arr) {
		int temp;//用于交换的数
		for(int i=0;i<arr.length;i++) {
			int maxIndex=i;
			for(int j=i;j<arr.length;j++) {
				if(arr[maxIndex]<arr[j])
					maxIndex=j;
			}
			temp=arr[i];
			arr[i]=arr[maxIndex];
			arr[maxIndex]=temp;
		}
		return arr;
	}
//	冒泡排序
	public static int[] propSort(int[] arr) {
		int temp;
		for(int length=arr.length;length>0;length--) {
			for(int index=0;index<length-1;index++) {
				if(arr[index]>arr[index+1]) {
					temp=arr[index];
					arr[index]=arr[index+1];
					arr[index+1]=temp;
				}
			}
		}
		return arr;
	}
//	插入排序
	 public static int[] insertSort(int[] arr) {
	        int i, j, insert;
	        for (i = 1; i < arr.length; i++) {
	            insert = arr[i];
	            j = i - 1;
	            while (j >= 0 && insert < arr[j]) {
	                arr[j + 1] = arr[j];
	                j--;
	            }
	            arr[j + 1] = insert;
	        }
	        return arr;
	    }
//	 生成斐波拉契数列
	 public static int[] fab(int n) {
		 int fab[]=new int[n];
		 fab[0]=1;
		 fab[1]=1;
		 for(int i=2;i<n;i++) {
			 fab[i]=fab[i-1]+fab[i-2];
		 }
		 return fab;
	 }
//	 希尔排序（以斐波拉契数列做步长）
	 public static int[] shellSort(int[] arr) {
		 int i = 0,temp = 0;
	     int fab[]=fab(10);
	        for (int index =fab.length-1 ; index >= 0; index--) {
	        	int step=fab[index];
	            for (int j = step; j < arr.length; j++) {
	                temp = arr[j];
	                for (i = j - step; i >= 0; i=i- step) {
	                    if (temp < arr[i]) {
	                    	arr[i + step] = arr[i];
	                    } else {
	                        break;
	                    }
	                }
	                arr[i + step] = temp;
	            }
	        }
	        return arr;
	 }
//	 快速排序
//	 单步
	 public static int sinFast(int[] arr,int i,int j) {
		 int compare=arr[i];
		 while(i<j) {
			 while(i<j&&arr[j]>=compare) {
				 j--;
			 }
			 if(i<j) {
				 arr[i]=arr[j];
				 i++;
			 }
			 while(j>i&&arr[i]<compare) {
				 i++;
			 }
			 if(i<j) {
				 arr[j]=arr[i];
				 j--;
			 }
		 }
		 arr[i]=compare;
		 return i;
	 }
//	 总排序
	 public static int[] fastSort(int i,int j,int arr[]) {
		 if(i<j) {
			 int index=sinFast(arr,i,j);
			 fastSort(i,index-1,arr);
			 fastSort(index+1,j,arr);
		 }
		 return arr;
	 }
//	 更换数组（将数组向后移以为，arr[0]用于存储原数组中的长度）
	 public static int[] arrChange(int[] arr) {
		 int length=arr.length;
		 int[] newArr=new int[length+1];
		 newArr[0]=length;
		 for(int index=0;index<length;index++) {
			 newArr[index+1]=arr[index];
		 }
		 return newArr;
	 }
//	 堆排序
	 public static int[] heapSort(int[] arr) {
		 while(arr[0]>0) {
			 for(int index=arr[0]/2;index>0;index--) {//当index*2或index*2+1小于长度时才进行操作，否则不进行任何操作
				 if(index*2+1<=arr[0]) {
					 int temp=Math.max(arr[index], Math.max(arr[index*2], arr[index*2+1]));//找出三个数中的最小数
					 if(arr[index]!=temp) {
						 if(arr[index*2]==temp) {
							 arr[index*2]=arr[index];
						 }
						 else {
							 arr[index*2+1]=arr[index];
						 }
						 arr[index]=temp;
					 }
				 }
				 else if(index*2<=arr[0]) {
					 if(arr[index]<arr[index*2]) {
						 int temp=arr[index];
						 arr[index]=arr[index*2];
						 arr[index*2]=temp;
					 }
				 }
			 }
			 int outNum=arr[1];
			 arr[1]=arr[arr[0]];
			 arr[arr[0]]=outNum;
			 arr[0]--;
		 }
		 return arr;
	 }
}