Java四种数组排序

package algorithm.sort;

import java.util.Random;

/**
 * @author  szy 
 * 2012-7-24
 */
public class Sort {
	/**
	 * 选择排序法
	 * 
	 * 基本思路:将要排序的数组分成两部分, 
	 * 一部分是从小到大已经排好序的,一部分是无序的, 
	 * 从无序的部队取出最小的数值,放到已经排好序的部分的最后
	 * 
	 * @param arr
	 * @return 
	 */
	public int[] choiceSort(int[] arr){
		int t,i=0,j;
		int len = arr.length;
		for(;i<len;i++){
			int m = i;
			for(j=i+1;j<len;j++){
				//如果j元素比m元素小,将j赋值给m
				if(arr[j] < arr[m]){
					m=j;
				}
			}
			//交换m和i两个元素的位置
			if(i != m){
				t = arr[i];
				arr[i] = arr[m];
				arr[m]=t;
			}
		}
		return arr;
	}
	
	/**
	 * 冒泡排序
	 * 
	 * 基本思路:从数组开始扫描待排序的元素
	 * 在扫描过程中依次对相邻元素进行比较,将数值大的元素后移
	 * 每经过一趟排序后,数值最大的元素将移到末尾
	 * 此时记下该元素的位置,
	 * 下一趟排序只需要比较到些位置为止
	 * 直到所有元素都己有序排列
	 * @param arr
	 * @return 
	 */
	public int[] bubblingSort(int[] arr){
		int t,i=0,j=0;
		int len = arr.length;
		for(;i<len;i++){
			//循环比较相邻两个元素大小
			for(;j<len-i-1;j++){
				//比较相邻元素大小,小的前移,大的后移
				if(arr[j]>arr[j+1]){
					t=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=t;
				}
			}
		}
		return arr;
	}
	
	/**
	 * 插入排序
	 * 
	 * 基本思路:将要排序的数组分成两部分
	 * 每次从后面的数组部分中取出索引最小的数组元素
	 * 插入到前面数组部分的适当位置中.
	 * 通常在开始排序时,将数组的第一个元素为一组,后面的所有元素被当成另一组
	 * 
	 * @param arr
	 * @return 
	 */
	public int[] insertSort(int[] arr){
		//将第一个元素看做一部分,第二个元素看做另一部分
		//从第二部分中依次取元素插入到第一部分中
		int i=1,j;
		int len = arr.length;
		for(;i<len;i++){
			int tmp = arr[i];
			j = i-1;
			//依次和i前面元素比较,寻找合插入位置
			while(tmp < arr[j]){
				arr[j+1] = arr[j];
				j--;
				if(j == -1){
					break;
				}
			}
			//将插入元素插入到合适位置
			arr[j+1] = tmp;
		}
		return arr;
	}
	
	/**
	 * 快速排序
	 * 
	 * 基本思路:将一个大的数组的排序分题,分解成2个小的数组的排序
	 * 而每个小的数组排序又可以继续分解成更小的2个数组.
	 * 这样一直递归分解下去 ,直到数组的大小最大为2
	 * 
	 * @param arr
	 * @param right arr.length-1
	 * @param left  0  
	 * @return 
	 */
	public int[] quickSort(int[] arr, int left, int right){
		int t,len = arr.length;
		
		if(left < right){
			int s = arr[left];
			int i = left;
			int j = right + 1;
			while(true){
				//向右找大于s的数的索引 
				while(i+1 < len && arr[++i] < s );
				//向左找小于s的数的索引
				while(j-1 > -1 && arr[--j] > s);
				//如果 i>=j 退出循环
				if(i>=j)
					break;
				else{
					//交换i和j位置
					t = arr[i];
					arr[i] = arr[j];
					arr[j] = t;
				}
			}
			arr[left] = arr[j];
			arr[j] = s;
			//对左边进行递归
			quickSort(arr,left,j-1);
			//对右边进行递归
			quickSort(arr,j+1,right);
		}
		return arr;
	}
	
	// Test
	public static void main(String[] args) {
		int i = 0, len = 100000;
		int[] arr = new int[len];
		Random rd = new Random();
		for (; i < len; i++) {
			arr[i] = rd.nextInt(len);
		}

		long millis = System.currentTimeMillis();
		 //new Sort().bubblingSort(arr); //26秒
		 //new Sort().choiceSort(arr); //287秒
		 new Sort().insertSort(arr);   //172秒
		//new Sort().quickSort(arr, 0, len - 1);//19秒
		for (i = 0; i < len; i++) {
			System.out.println(arr[i]);
		}

		System.out.println("用时:" + (System.currentTimeMillis() - millis) / 100
				+ "秒");
	}
}