java排序(插入、希尔、堆、归并、基数、快排)

1. 插入排序
   【直接插入】
   将数组分为有序区和无序区，例524613，有序区为5，无序区为24613，依次将无序区中的每个元素插入到有序区中

private int[] insertSort1(int[] arr){
		for(int i=1;i<arr.length;i++){
			int j=i-1;
			for(;j>=0;j--){
				if (arr[j]<arr[i]) {
					break;
				}
			}
			if (j!=i-1) {
				int temp=arr[i];
				int k=i-1;
				for(;k>j;k--){
					arr[k+1]=arr[k];
				}
				arr[k+1]=temp;
			}
		}
		return arr;
	}

【二分插入】
将数组置上三个标记：left、right、mid；在插入下标为 i 的元素时，对前面的 [0,i-1] 进行折半，如果比 mid 小，则对前折半；否则对后折半，直至left<=right不成立，然后将元素后移插入。

private int[] insertSort2(int[] arr){
		for(int i=1;i<arr.length;i++){
			int temp=arr[0];
			int left=0,right=i-1,mid;
			while (left<=right){
				mid=left+(right-left)/2;
				if (arr[mid]>temp) {
					right=mid-1;
				}else {
					left=mid+1;
				}
			}
			for(int j=i-1;j>=left;j--)
				arr[j+1]=arr[j];
			arr[left]=temp;
		}
		return arr;
	}

2. 希尔排序
   算是插入排序的一种。主体思想是分组排序，首先确定间距(或称增量)，一般为length/2，进行组内排序，直至间距为1。

private int[] shellSort(int[] arr) {
		for(int gap=arr.length/2;gap>0;gap/=2){
			for(int i=gap;i<arr.length;i++){
				int temp=arr[i];
				int j=i-gap;
				for(;j>=0&&temp<=arr[j];j-=gap){
					arr[j+gap]=arr[j];
				}
				arr[j+gap]=temp;
			}
		}
		return arr;
	}

3. 堆排序
   首先构建大顶堆，然后再将最大值置于尾部，例{7,3,5,8,9,17,15,1}，首次构建堆结果为{7,3,17,8,9,5,15,1}，第二次构建结果为{7,9,17,8,3,5,15,1}，第三次为{17,9,15,8,3,5,7,1}，再进行置尾操作。

private int[] heapSort(int[] arr) {
		for (int i = arr.length/2; i >=0 ; i--) {
			percDown(arr,i,arr.length);
		}
		for (int i = arr.length-1; i > 0; i--) {
			//swap(0,i,arr)
			int a=arr[0];
			arr[0]=arr[i];
			arr[i]=a;
			percDown(arr, 0, i);
		}
		return arr;
	}
	private void percDown(int[] arr, int i, int n) {
		int child,temp;
		for(temp=arr[i];i*2+1<n;i=child){
			child=i*2+1;
			if (child!=n-1&&arr[child+1]>arr[child])
				child++;
			if (temp<arr[child]) {
				arr[i]=arr[child];
			}else {
				break;
			}
			arr[i]=temp;
		}
	}

4. 归并排序
   采用分治法的思想，将数组分解为子序列，对子序列排序，然后对有序序列排序并合并。

private void mergeSort(int[] arr,int[] tempArr,int startIndex,int endIndex) {
		if (endIndex<=startIndex) {
			return ;
		}
		int midIndex=startIndex+(endIndex-startIndex)/2;
		mergeSort(arr, tempArr, startIndex, midIndex);
		mergeSort(arr, tempArr, midIndex+1, endIndex);
		merge(arr,tempArr,startIndex,midIndex,endIndex);
	}
	private void merge(int[] arr,int[] tempArr,int startIndex,int midIndex, int endIndex) {
		for(int s=startIndex;s<=endIndex;s++){
			tempArr[s]=arr[s];
		}
		int left=startIndex,right=endIndex;
		for(int k=startIndex;k<=endIndex;k++){
			if (left>midIndex) {
				arr[k]=tempArr[right++];
			}else if(right>endIndex){
				arr[k]=tempArr[left++];
			}else if (tempArr[right]>tempArr[left]) {
				arr[k]=tempArr[right++];
			}else {
				arr[k]=tempArr[left++];
			}
		}
	}

5. 基数排序
   根据位数采用下标对应的方式，从个位直到最高位。

private void radixSort(int[] arr) {
		int n=1;
		for (int i : arr) {
			int temp=1;
			for(int j=i/10;j!=0;j/=10){
				temp++;
			}
			if (temp>n) {
				n=temp;
			}
		}
		LinkedList<LinkedList<Integer>> list=new LinkedList<>();
		for(int i=0;i<n;i++){
			//入表
			for (int v : arr) {
				int index=v%10;
				LinkedList<Integer> inList=list.get(index);
				if (inList==null) {
					inList=new LinkedList<>();
				}
				inList.add(v);
				list.add(index,inList);
			}
			//出表
			int j=0;
			for (LinkedList<Integer> linkedList : list) {
				for (Integer integer : linkedList) {
					arr[j]=integer;
					j++;
				}
			}
		}
	}

6. 快速排序
   取中间位作哨兵，left 为0，right 为 arr.length-1，分别向中间靠拢，当 left 位和 right 位比较大小时，小向前靠，大向后，对调，如果 left==right，对调哨兵和 left 位（right 位）。

private void quickSort(int[] arr,int left,int right) {
		if (left<right) {
			int temp=division(arr,left,right);
			quickSort(arr, left, temp-1);
			quickSort(arr, temp+1, right);
		}
	}
	private int division(int[] arr, int left, int right) {
		int temp=arr[left];
		while (left<right){
			while (left<right&&arr[right]>=temp) {
				right--;				
			}
			arr[left]=arr[right];
			while (left<right&&arr[left]<=temp){
				left++;
			}
			arr[right]=arr[left];
		}
		arr[left]=temp;
		return left;
	}