五个常见Java排序算法

最近从网上学习了几个常见的java排序算法，特意整合了5个排序算法如下：

package test;

/**
 * @fileName Algorithm.java
 * @Description
 * @author chen
 * @date 2017年8月29日
 * @version 1.0
 */
public class Algorithm {
	
	/**
	 * 冒泡排序
	 * 算法的运作如下：
	 * 1:比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置。
	 * 2:对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
	 * 3:针对所有的元素重复以上的步骤，除了最后一个。
	 * 4:持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
	 * @param array
	 */
	public void bubbleSort(int[] array){
		for(int j=0;j<array.length-1;j++){
			for(int i=0;i<array.length-1-j;i++){
				if(array[i]>array[i+1]){
					swap(array,i,i+1);
				}
			}
		}
	}
	
	/**
	 * 选择排序
	 * 具体算法描述如下：
	 * 1:初始时在序列中找到最小（大）元素，放到序列的起始位置作为已排序序列；
	 * 2:然后，再从剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾。
	 * 3:以此类推，直到所有元素均排序完毕。
	 * @param array
	 */
	public void selectSort(int[] array){
		for(int i=0;i<array.length;i++){
			int min = i;
			for(int j=i+1;j<array.length;j++){
				if(array[min]>array[j]){
					min = j;
				}
			}
			if(min != i){
				swap(array,min,i);
			}
		}
	}

	/**
	 * 插入排序
	 * 具体算法描述如下：
	 * 1:从第一个元素开始，该元素可以认为已经被排序
	 * 2:取出下一个元素，在已经排序的元素序列中从后向前扫描
	 * 3:如果该元素（已排序）大于新元素，将该元素移到下一位置
	 * 4:重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
	 * 5:将新元素插入到该位置后
	 * 6:重复步骤2~5
	 * @param array
	 */
	public void insertSort(int[] array){
		for(int i=1;i<array.length;i++){
			for(int j=i;j>0;j--){
				if(array[j]<array[j-1]){
					swap(array,j,j-1);
				}
			}
		}
	}
	
	/**
	 * 希尔排序
	 * 基本思想是：
	 * 1:先将整个待排元素序列分割成若干个子序列（由相隔某 个“增量”的元素组成的）分别进行直接插入排序，
	 * 2:然后依次缩减增量再进行排序，
	 * 3:待整个序列中的元素基本有序（增量足够小）时，
	 * 4:再对全体元素进行一次直接插 入排序。
	 * 因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，
	 * 因此希尔排序在时间效率上比前两种方法有较大提高。
	 * @param array
	 */
	public void shellSort(int[] array){
		for(int gap=array.length/2;gap>0;gap/=2){

			for(int i=gap;i<array.length;i++){
				for(int j=i;j>gap-1;j=j-gap){	//j>gap-1,避免数组越界,当gap=1时，实际就是直接插入排序
					if(array[j]<array[j-gap]){
						swap(array,j,j-gap);
					}
				}
			}
		}
	}

	
	/**
	 * 快速排序  
	 * 该方法的基本思想是：
	 * 1．先从数列中取出一个数作为基准数。
	 * 2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
	 * 3．再对左右区间重复第二步，直到各区间只有一个数。
	 * @param s
	 * @param l
	 * @param r
	 */
	void quick_sort(int s[], int l, int r)  
	{  
	    if (l < r)  
	    {  
	        int i = l, j = r, x = s[l];  
	        while (i < j)  
	        {  
	            while(i < j && s[j] >= x) // 从右向左找第一个小于x的数  
	                j--;
	            if(i < j){   
	                s[i] = s[j];
	                i++;
	            }
	            while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数  
	                i++;
	            if(i < j){
	            	s[j] = s[i];
	            	j--;
	            }
	                 
	        }  
	        s[i] = x;  
	        quick_sort(s, l, i - 1); // 递归调用   
	        quick_sort(s, i + 1, r);  
	    }  
	}  
	
	public static void main(String[] args) {
		Algorithm alg = new Algorithm();
		int[] array = {1,4,2,45,6,13,3,33,8,5,21,9,7,21};
		System.out.println("befor sorting array:");
		print(array);
		System.out.println();
		
//		alg.bubbleSort(array);
//		alg.selectSort(array);
//		alg.insertSort(array);
		//alg.shellSort(array);
		alg.quick_sort(array, 0, array.length-1);
		
		System.out.println("after sorting array:");
		print(array);
	}
	
	public void swap(int[] a,int i,int j){
		int temp = a[i];
		a[i] = a[j];
		a[j]=temp;
	}
	
	public static void print(int[] a){
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+" ");
		}
	}
  

}