排序算法java实现

典型的排序算法有：

基础版：冒泡排序，简单选择排序，插入排序，归并排序

升级版:堆排序，希尔排序，快排，归并排序，

还有一些桶排序，计数排序等，这里没有实现

java代码实现如下：

package org.cn.sort;



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



public class AllSortMethodDemo {
	public static void main(String[] args){
		AllSortMethodDemo demo=new AllSortMethodDemo();
		demo.test();
	}
	public void test(){
		AllSortMethodDemo demo=new AllSortMethodDemo();
		int[] data={2,4,3,1,10,8,9,7,0,5,6,3};
		//MaoPao3(data);
		//selectSort(data);
		//insertSort2(data);
		//shellSort(data);
	    //headSort(data);
		//mergeSort(data,0,data.length-1);
		quickSort(data, 0, data.length-1);
		printData(data);
		//System.out.println("\n"+Arrays.toString(data));
		
	}
	public void printData(int[] data){
		for(int i=0;i<data.length;i++){
			System.out.print(data[i]+" ");
		}
	}
	public void swap(int[] arr,int i,int j){
		if(i<0 || i>=arr.length || j<0 || j>=arr.length){
			return ;
		}
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}
	/**
	 * 冒泡排序基础版
	 * @param arr
	 */
	public void maoPao1(int[] arr){
		if(arr==null || arr.length==0){
			return ;
		}
		for(int i=0;i<arr.length;i++){
			for(int j=i+1;j<arr.length;j++){
				if(arr[i]>arr[j]){
					swap(arr, i, j);
				}
			}
		}
	}
	/**
	 * 冒泡排序升级版
	 * @param arr
	 */
	public void maoPao2(int[] arr){
		if(arr==null || arr.length==0){
			return;
		}
		for(int i=0;i<arr.length;i++){
			for(int j=arr.length-1;j>i;j--){
				if(arr[j]<arr[j-1]){
					swap(arr, j, j-1);
				}
			}
		}
	}
	/**
	 * 冒泡排序优化版
	 * 增加了flag标志判断，减少了不必要的比较次数
	 * @param arr
	 */
	public void maoPao3(int[] arr){
		if(arr==null || arr.length==0){
			return;
		}
		boolean flag=true;  
		for(int i=0;i<arr.length && flag;i++){
			flag=false;
			for(int j=arr.length-1;j>i;j--){
				if(arr[j]<arr[j-1]){
					swap(arr, j, j-1);
					flag=true;
				}
			}
		}
	}
	/**
	 * 简单选择排序
	 * @param arr
	 */
	public void selectSort(int[] arr){
		if(arr==null || arr.length==0){
			return;
		}
		int min;
		for(int i=0;i<arr.length;i++){
			min=i;
			for(int j=i+1;j<arr.length;j++){
				if(arr[min]>arr[j]){
					min=j;
				}
			}
			if(min!=i){
				swap(arr, min, i);
			}
		}
	}
	/**
	 * 直接插入排序
	 * @param arr
	 */
	public void insertSort(int[] arr){
		if(arr.length==0 ||arr==null){
			return;
		}
		for(int i=1;i<arr.length;i++){
			if(arr[i]<arr[i-1]){
				int temp=arr[i];
				int j;
				for(j=i-1;j>=0 && arr[j]>temp;j--){
					arr[j+1]=arr[j];
				}
				arr[j+1]=temp;
			}
		}
	}
	/**
	 * 直接插入排序2
	 * @param arr
	 */
	public void insertSort2(int[] arr){
		if(arr.length==0 ||arr==null){
			return;
		}
		for(int i=1;i<arr.length;i++){
			if(arr[i]<arr[i-1]){
				int temp=arr[i];
				int j;
				for(j=i-1;j>=0;j--){
					if(arr[j]>temp){
						arr[j+1]=arr[j];
					}else{
						break;
					}
				}
				arr[j+1]=temp;
			}
		}
	}
	/**
	 *希尔排序，实际为直接插入排序的升级版，优化版
	 *直接插入排序的升级版
	 * @param arr
	 */
	public void shellSort(int[] arr){
		if(arr.length==0 || arr==null){
			return;
		}
		int temp=0;
		int j=0;
		for(int increment=arr.length/2;increment>0;increment/=2){
			System.out.println("increment:"+increment);
			for(int i=increment;i<arr.length;i++){
				temp=arr[i];
				int count=0;
				for(j=i-increment;j>=0;j-=increment){
					if(arr[j]>temp){
						arr[j+increment]=arr[j];
						count++;
					}else{
						break;
					}
				}
				arr[j+increment]=temp;
				System.out.print("比较了："+count+"次，第"+(i-increment)+"次排序之后，数组为：");
				printData(arr);
				System.out.println();
			}
		}
	}
	
	
	/*
	 * 
	 * 堆排序
	 */
    public void headSort(int[] array){
    	if(array.length==0 || array==null){
    		return;
    	}
    	for(int i=array.length/2-1;i>=0;i--){
    		headAjust(array, i, array.length-1);
    	}
    	for(int i=array.length-1;i>=0;i--){
    		int temp=array[i];
    		array[i]=array[0];
    		array[0]=temp;
    		headAjust(array, 0, i-1);
    	}
    }
    /**
     * 构造最大堆
     * @param array
     * @param i
     * @param len
     */
    public void headAjust(int[] array,int i,int len){
    	if(array==null ||array.length==0){
    		return;
    	}
    	int temp=array[i];
    	for(int j=2*i+1;j<=len;j*=2){
    		if(j+1<=len && array[j]<array[j+1]){
    			j++;
    		}
    		if(temp>array[j]){
    			break;
    		}
    		array[i]=array[j];
    		i=j;
    	}
    	array[i]=temp;
    }
    /*
     * 
     * 归并排序中的合并操作
     */
    public void merge(int[] array,int low,int mid,int hight){
    	int[] temp=new int[hight-low+1];
    	int k=0;
    	int left=low;
    	int right=mid+1;
    	while(left<=mid && right<=hight){
    		if(array[left]>array[right]){
    			temp[k++]=array[right++];
    		}else{
    			temp[k++]=array[left++];
    		}
    	}
    	//如果两边的长度不一样，可能左边还有剩余，也可能是右边还有剩余
    	while(left<=mid){
    		temp[k++]=array[left++];
    	}
    	while(right<=hight){
    		temp[k++]=array[right++];
    	}
    	//将临时数组中的值复制到原来的数组之中
    	for(int i=0;i<temp.length;i++){
    		array[low+i]=temp[i];
    	}
    }
    
    /**
     * 归并排序
     * @param array
     * @param low
     * @param hight
     */
    public void mergeSort(int[] array,int low ,int hight){
    	if(low>=hight){
    		return;
    	}
    	int mid=low+(hight-low)/2;
    	mergeSort(array, low, mid);
    	mergeSort(array,mid+1, hight);
    	merge(array, low, mid, hight);
    	System.out.println(Arrays.toString(array));
    }
    /**
     * 快排
     * @param array
     * @param low
     * @param high
     */
    public void quickSort(int[] array,int low,int high){
    	int position;
    	if(low<high){
    		position=partition(array, low, high);
    		
    		quickSort(array, low, position-1);
    		quickSort(array, position+1, high);
    	}
    }
    /*
     * 快排辅助方法
     */
    public int partition(int[] array,int low ,int high){
    	int pointKey=array[low];
    	while(low<high){
    		while(low<high && array[high]>=pointKey){
    			high--;
    		}
    		swap(array, low, high);
    		
    		while(low<high && array[low]<=pointKey){
    			low++;
    		}
    		swap(array, low, high);
    	}
    	return low;
    }
    /**
     * 快排辅助方法2
     * 优化方法，减少不必要的交换
     * @param array
     * @param low
     * @param high
     * @return
     */
    public int partition2(int[] array,int low ,int high){
    	int pointKey=array[low];
    	while(low<high){
    		while(low<high && array[high]>=pointKey){
    			high--;
    		}
    		array[low]=array[high];
    		
    		while(low<high && array[low]<=pointKey){
    			low++;
    		}
    		array[high]=array[low];
    	}
    	array[low]=pointKey;
    	return low;
    }
}