常见排序的Java实现

简单排序：冒泡、选择、插入                时间复杂度：O(n^2)

复杂排序：希尔、归并、快速                时间复杂度：O(nlogn)

具体实现代码如下：

public class Sort {

	public static void main(String[] args) {
		int[] data = {4,3,7,9,8,2,1,5,6};
		bubbleSort(data);
		data = new int[]{4,3,7,9,8,2,1,5,6};
		selectSort(data);
		data = new int[]{4,3,7,9,8,2,1,5,6};
		insertSort(data);
		data = new int[]{4,3,7,9,8,2,1,5,6};
		mergeSort(data);
		data = new int[]{4,3,7,9,8,2,1,5,6};
		shellSort(data);
		data = new int[]{4,3,7,9,8,2,1,5,6};
		quickSort(data);

	}

/***********************************************************************/
	//冒泡排序
	public static void bubbleSort(int[] arr){
		int temp;int len=arr.length;
		for(int i=0;i<len-1;i++){            //两次for循环
			for(int j=0;j<len-i-1;j++){      //每趟循环均从0开始，，把这趟最大的数交换至最后。
				if(arr[j]>arr[j+1]){
					temp = arr[j+1];
					arr[j+1] = arr[j];
					arr[j] = temp;
				}
			}
		}
		System.out.print("冒泡排序:");
		for(int i=0;i<len;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}

/*******************************************************************/
	//选择排序
	public static void selectSort(int[] arr){
		int temp;int len=arr.length;int flag;
		for(int i=0;i<len-1;i++){               //两次for循环
			temp = arr[i];flag = i;         //每趟找出一个最小值，放在指定位置
			for(int j=i+1;j<len;j++){
				if(temp>arr[j]){
					temp = arr[j];
					flag = j;
				}
			}
			if(flag != i){
				arr[flag] = arr[i];
				arr[i] = temp;
			}
			
		}
		System.out.print("选择排序:");
		for(int i=0;i<len;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}

/*********************************************************************/
	//插入排序
	public static void insertSort(int[] arr){    
		int len = arr.length;int temp;int j;
		for(int i=1;i<len;i++){
			temp = arr[i];
			j = i;
			while(j > 0){
				if(arr[j-1]>temp){
					arr[j] = arr[j-1];
					arr[j-1] = temp;
				}else{
					break;
				}
				j--;
			}
		}
		System.out.print("插入排序:");
		for(int i=0;i<len;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}

/**********************************************************************/	
	
	//归并排序
	public static void mergeSort(int[] arr){
		int len = arr.length;                   //求数组长度len
		recMergeSort(arr,0,len-1);              //调用静态方法，输入:数组，起点，终点
		System.out.print("归并排序:");           //处理完成的打印
		for(int i=0;i<len;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}
	//处理归并排序
	private static void recMergeSort(int[] arr,int start,int end){
		if(start==end){                         //分解到只剩一个数字，出递归
			return;
		}
		int mid = (start+end)/2;    
		recMergeSort(arr,start,mid);//递归前半部分排序处理
		recMergeSort(arr,mid+1,end);//递归后半部分排序处理
		merge(arr,start,mid+1,end); //一层一层的合并
		
	}
	private static void merge(int[] arr, int start, int midM, int end) {      //合并的程序
		int j=0; int startM = start;        //start end为要合并的起点终点
		int mid = midM-1;               //mid是前半部分的临界，end是后半部分的临界
		int n = end-start+1;         //要归并的数量                                                                           //startM是将来要参与比较的，可移动的，，同理midM
		int[] tempArr = new int[n]; 
/*		for(int i=0;i<n;i++){
			if(start<=mid && midM<=end){
				if(start<midM){
					tempArr[i] = arr[start];
					start++;continue;
				}else{
					tempArr[i] = arr[midM];
					midM++;continue;
				}
			}
			if(start<=mid){
				tempArr[i] = arr[start];
				start++;continue;
			}
			if(midM<=end){
				tempArr[i] = arr[midM];
				midM++;continue;
			}
			
		}
		for(int i=0;i<n;i++){
			arr[sta+i] = tempArr[i];
		}*/
		while(startM<=mid && midM<=end){
			if(arr[startM] <= arr[midM]){
				tempArr[j++] = arr[startM++];
			}else{
				tempArr[j++] = arr[midM++];
			}
		}
		while(startM<=mid){
			tempArr[j++] = arr[startM++];
		}
		while(midM<=end){
			tempArr[j++] = arr[midM++];
		}
		for(int i=0;i<n;i++){
			arr[start+i] = tempArr[i];
		}
	}

/*************************************************************************/
	//希尔排序
	public static void shellSort(int[] arr){
		int len = arr.length;
		int inner;int outer;
		int temp;
		int h = 1;  //h = h*3+1
		while(h<=len/3){
			h = h*3+1;
		}
		while(h>0){
			for(outer=h;outer<len;outer++){
				temp = arr[outer];
				inner = outer;
				while(inner>h-1 && arr[inner-h]>=temp){
					arr[inner] = arr[inner-h];
					inner = inner - h;
				}
				arr[inner] = temp;
			}
			h = (h-1)/3;
		}
		System.out.print("希尔排序:");           //处理完成的打印
		for(int i=0;i<len;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.println();
		
	}
	
/********************************************************************/
	
	//快速排序
	public static void quickSort(int[] arr){
		int len = arr.length;
		split(arr,0,len-1);
		System.out.print("快速排序:");           //处理完成的打印
		for(int i=0;i<len;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}

    private static void split(int[] arr, int start, int end) {
    	int i,j;int temp;
    	if(start == end){
    		return;
    	}
    	i = start; j = end;               //i j 是用来移动的"指针"
    	temp = arr[i];                    //把最左的值用temp记录，同时也是比较的中间值。
    	while(i<j){
    		while(i<j && arr[j]>=temp){   //把指针移到小于大于temp的位置
    			j--;
    		}
    		if(i<j){
    			arr[i++] = arr[j];        //将该处的值赋值给左边,左边指针加1,   注意此时右边指针没走!!
    		}
    		while(i<j && arr[i]<temp){    //到大于temp的位置
    			i++;
    		}
    		if(i<j){  //因为右边指针刚没走，这次把左边不符合的换到右边那个位置。然后，右边指针左移
    			arr[j--] = arr[i];  //注，每次把值赋给别人时，自己位置不会变。
    		}
    	}
    	arr[i] = temp; //上述情况总会产生一个重复的，要改变的值位置，当左右重合时，用temp，即分界值来填充 =>此时i=j
    	split(arr,start,i);
    	split(arr,i+1,end);
    }
	

}