各种排序算法、java实现

/**
 * 各种排序算法
 * @author chenxiruanhai
 * @Date 2015-1-7
 */
public class Sort {

	public static void main(String[] args) {

		int[] arr = { 1, 4, 3, 8, 2 };
		int len = arr.length;

		// bubbleDown(arr, len); //冒泡下沉
		// bubbleUp(arr, len);   //冒泡上浮
		// choose(arr, len); //选择排序
		// insert(arr, len); //插入排序
		// quicksort(arr, 0,len-1); //快速排序

		show(arr);

	}

	
	/*快速排序*/
	static void quicksort(int n[], int left, int right) {

        int dp;

        if (left < right) {

            dp = partition(n, left, right);

            quicksort(n, left, dp - 1);

            quicksort(n, dp + 1, right);

        }

    }
	static int partition(int n[], int left, int right) {

        int pivot = n[left];

        while (left < right) {

            while (left < right && n[right] >= pivot)

                right--;

            if (left < right)

                n[left++] = n[right];

            while (left < right && n[left] <= pivot)

                left++;

            if (left < right)

                n[right--] = n[left];

        }

        n[left] = pivot;

        return left;

    }
	
	
	
	/**
	 *  插入排序
	 *  插入排序的原理：始终定义第一个元素为有序的，将元素逐个插入到有序排列之中，其特点是要不断的移动数据，空出一个适当的位置，把待插入的元素放到里面去。
	 * @param arr
	 * @param len
	 */
	private static void insert(int[] arr, int len) {
		int i, j, tmp;
		for (i = 1; i < len; i++) {
			j = i - 1;
			tmp = arr[i];
			while (j >= 0 && arr[j] > tmp) {
				arr[j + 1] = arr[j];
				j--;
			}
			arr[j + 1] = tmp;
		}
	}
	
	/**
	 *  选择排序
	 *  原理：选择排序的原理：每次在无序队列中“选择”出最小值，放到有序队列的最后，并从无序队列中去除该值（具体实现略有区别）
	 * @param arr
	 * @param len
	 */
	private static void choose(int[] arr, int len) {
		int i, j, k, temp;
		for (i = 0; i < len; i++) {
			k = i;
			for (j = i + 1; j < len; j++) {
				if (arr[k] < arr[j])
					k = j;
			}
			if (k != i) {
				temp = arr[i];
				arr[i] = arr[k];
				arr[k] = temp;
			}
		}
	}

	/**
	 * 冒泡下沉
	 * @param arr
	 * @param len
	 * @return
	 */
	private static int bubbleDown(int[] arr, int len) {
		for(int i=0;i<len;len--){
			
			for(int j=i;j<len-1;j++){
				
				if(arr[j]<arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1]=temp;
				}
				
			}
		}
		return len;
	}

	/**
	 * 冒泡上浮
	 * 原理： 冒泡排序的原理：每次在无序队列里将相邻两个数依次进行比较，将小数调换到前面，逐次比较，直至将最大的数移到最后。最将剩下的N-1个数继续比较，将次大数移至倒数第二位。依此规律，直至比较结束。
	 * @param arr
	 * @param len
	 */
	private static void bubbleUp(int[] arr, int len) {
		for(int i=0;i<len;i++){
			for(int j=i;j<len-1;j++){
				if(arr[j]>arr[j+1]){
					int max = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = max;
				}
			}
		}
	}

	/**
	 * 打印
	 */
	private static void show(int[] arr) {
		for (int f : arr) {
			System.out.println(f);
		}
	}
}