常见排序java实现

package test;

import java.util.ArrayList;
import java.util.Arrays;


public class Test4 {
	/**
	 * 插入排序
	 * 时间复杂度O(n^2)
	 * 空间复杂度O(1)
	 * 稳定排序
	 * 最好O(n),最坏O(n^2)
	 */
	static void insertSolve(int[] arr){		
		for(int i=0;i<arr.length;i++){
			int temp = arr[i];
			for(int j=i-1;j>=0;j--){//往前找				
				if(arr[j]>=temp){
					arr[j+1] = arr[j];					
				}else{
					arr[j+1] = temp;
					break;
				}
			}
		}
	}
	
	/**
	 * 折半插入排序
	 * 时间复杂度O(n^2)
	 * 空间复杂度O(1)
	 * 稳定排序
	 * 最好O(n),最坏O(n^2)
	 */
	static void insertSolve2(int[] arr){		
		for(int i=0;i<arr.length;i++){
			int temp = arr[i];
			int low = 0;
			int high = i-1;
			while(low<=high){
				int mid = (low+high)/2;
				if(temp<arr[mid]){
					high = mid-1;
				}else{
					low = mid+1;
				}
			}
			for(int j=i-1;j>high;j--){
				arr[j+1] = arr[j];
			}
			arr[high+1] = temp;
		}
	}
	
	/**
	 * 希尔排序
	 * @param n 增值
	 * 时间复杂度O(n^1.3)
	 * 空间复杂度O(1)
	 * 不稳定排序
	 */
	static void shell(int[] arr,int n){
		int len = arr.length;		
		while(n>0){
			for(int i=n;i<len;i++){
				int temp = arr[i];
				int j = i-n;
				while(j>=0 && arr[j]>temp){
					arr[j+n] = arr[j];
					j -= n;
				}
				arr[j+n] = temp;
			}
			n = n/2;
			System.out.println(n);
		}
	}
	
	/**
	 * 选择排序
=	 * 时间复杂度O(n^2)
	 * 空间复杂度O(1)
	 * 不稳定排序
	 * 最好O(n^2),最坏O(n^2)
	 */
	static void selectSort(int[] arr){
		int len = arr.length;
		for(int i=0;i<len-1;i++){
			int min = i;
			for(int j=i+1;j<len;j++){
				if(arr[j]<arr[min]){
					min = j;
				}
			}
			if(min!=i){
				int temp = arr[i];
				arr[i] = arr[min];
				arr[min] = temp;
			}
		}
	}
	
	/**
	 * 把low到high调节成堆
	 * @param arr
	 * @param low
	 * @param high
	 */
	static void sift(int[] arr,int low,int high){
		int i = low;
		int j = 2*i;
		int temp = arr[i];
		while(j<=high){
			if(j<high && arr[j]<arr[j+1]){
				j++;
			}
			if(temp<arr[j]){
				arr[i] = arr[j];
				i = j;
				j = 2*i;
			}else{
				break;
			}
		}
		arr[i] = temp;
	}
	
	/**
	 * 堆排序
	 * 时间复杂度O(nlogN)
	 * 空间复杂度O(1)
	 * 不稳定排序
	 * 最好O(nlogN),最坏O(nlogN)
	 */
	static void headSort(int[] arr){
		int len = arr.length;
		int i = 0;
		for(i=len/2;i>=1;i--){
			sift(arr,i,len-1);
		}
		
		for(i=len-1;i>=2;i--){
			int temp = arr[i];
			arr[i] = arr[1];
			arr[1] = temp;
			sift(arr,1,i-1);
		}
	}
	
	/** 
	 * 冒泡排序
	 * 时间复杂度O(n^2)
	 * 空间复杂度O(1)
	 * 稳定排序
	 * 最好O(n),最坏O(n^2)
	 */
	static void bubbleSort(int[] arr){
		for(int i=0;i<arr.length;i++){
			boolean flag = false;
			for(int j=1;j<arr.length-i;j++){
				if(arr[j]<arr[j-1]){
					int temp = arr[j];
					arr[j] = arr[j-1];
					arr[j-1] = temp;
					flag = true;
				}
			}
			if(flag){
				return;
			}
		}
	}
	
	/**
	 * 把元素按标志位左右分配
	 * @param arr
	 * @param low
	 * @param high
	 * @return
	 */
	static int partition(int[] arr,int low,int high){
		int flag = arr[low];
		while(low<high){
			while(low<high && arr[high]>=flag){
				high--;
			}
			arr[low] = arr[high];
			while(low<high && arr[low]<=flag){
				low++;
			}
			arr[high] = arr[low];
		}
		arr[low] = flag;
		return low;
	}
	
	/** 
	 * 快速排序
	 * 时间复杂度O(nlogN)
	 * 空间复杂度O(1)
	 * 不稳定排序
	 * 最好O(nlogN),最坏O(n^2)
	 */
	static void quickSort(int[] arr,int low,int high){
		if(low<high){
			int mid = partition(arr, low, high);
			quickSort(arr, low, mid-1);
			quickSort(arr, mid+1, high);
		}
	}
	
	/** 
	 * 快速排序(非递归解法)
	 * 时间复杂度O(nlogN)
	 * 空间复杂度O(logN)
	 * 不稳定排序
	 * 最好O(nlogN),最坏O(n^2)
	 */	
	static void quickSort2(int[] arr){
		int n = arr.length-1;
		int max = 100;
		int flag = 0;
		int[] start = new int[max];
		int[] end = new int[max];
		int top = 0;
		start[top] = 0;
		end[top] = n;
		while(top>-1){
			int i = start[top];
			int j = end[top];
			int low = start[top];
			int high = end[top];
			top--;		
			if(low<high){
				flag = arr[low];
				while(low<high){					
					while(low<high && arr[high]>=flag){
						high--;
					}
					arr[low] = arr[high];
					while(low<high && arr[low]<=flag){
						low++;
					}
					arr[high] = arr[low];
				}
				arr[low] = flag;
				top++;
				start[top] = i;end[top] = low-1;
				top++;
				start[top] = low+1;end[top] = j;		
			}
		}
		
	}
	
	/**
	 * 归并排序
	 * 时间复杂度O(nlogN)
	 * 空间复杂度O(n)
	 * 稳定排序
	 * 最好O(nlogN),最坏O(nlogN)
	 */
	static void MergeSort(int[] arr,int start,int end){  
        if(end==start) return;//如果要排序的只有一个数，直接返回  
          
        int mid = (end+start)/2;//把数组分成两部分，这里不一定是平均分，但没有影响  
        MergeSort(arr,start,mid);//左部分排序  
        MergeSort(arr,mid+1,end);//右部分排序  
        int len = end-start+1;//数组长度  
        int[] arr2 = new int[len];//申请一个相同大小的数组，作为暂存          
        int num = 0,i=start,j=mid+1;  
        for(;i<=mid && j<=end;){//直到某个数组完全分配好  
            if(arr[i] < arr[j]){//比较大小，按大小存入暂存数组  
                arr2[num] = arr[i];   
                i++;  
            }else{  
                arr2[num] = arr[j];  
                j++;  
            }  
            num++;  
        }                 
        //分配剩余数组，直接按顺序复制就可以了  
        for(;i<=mid;i++){  
            arr2[num++] = arr[i];  
        }  
        for(;j<=end;j++){  
            arr2[num++] = arr[j];  
        }  
          
        for(int i1=start;i1<end+1;i1++){  
            arr[i1] = arr2[i1-start];  
        }  
        arr2 = null;//清空方便回收      
    }  
	
	/**
	 * 获得某数的某一位
	 * @param num
	 * @param pos
	 * @return
	 */
	static int GetNumInPos(int num,int pos)  {  
	    int temp = 1;  
	    for (int i = 0; i < pos - 1; i++)  
	        temp *= 10;  	  
	    return (num / temp) % 10;  
	}  
	
	/**
	 * 基数排序
	 * 时间复杂度O(n+r)
	 * 空间复杂度O(n+r)
	 * 稳定排序
	 * 最好O(n+r),最坏O(n+r)
	 */
	static void radixSort(int[] arr){
		int len = arr.length;
		ArrayList<ArrayList<Integer>> radixArrays = new ArrayList<ArrayList<Integer>>();
		for(int i=0;i<10;i++){
			radixArrays.add(new ArrayList<Integer>());
		}
		int max = 31;//最大位数
		for(int i=0;i<=31;i++){
			for(int j=0;j<len;j++){//分配
				radixArrays.get(GetNumInPos(arr[j], i+1)).add(arr[j]);
			}
			int index = 0;
			for(int j=0;j<10;j++){//收集
				for(Integer integer:radixArrays.get(j)){
					arr[index] = integer;
					index++;
				}
				radixArrays.get(j).clear();
			}
		}
	}
		
	
	public static void main(String[] args) {
		int[] arr = new int[]{1,3,5,2,7,4,76,34,12};
		radixSort(arr);
		System.out.println(Arrays.toString(arr));
	}
}