算法之冒泡排序和快速排序

package com.sort.test;

import java.util.Arrays;
import java.util.Random;

public class VeriableSort {
    private static int MAX_NUMBER=10;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = new int[MAX_NUMBER];
        Random rand = new Random();
        for(int i = 0; i < MAX_NUMBER; i++){
            array[i] = rand.nextInt(20);
        }
        //原始的数组序列
        System.out.println("原始的数组排序如下：");
        System.out.println(Arrays.toString(array));
//        bubbleSort(array);
        System.out.println("冒泡排序后的数组排序如下：");
        System.out.println(Arrays.toString(array));
        quickSort(array,0,array.length-1);
        System.out.println("快速排序后的数组排序如下：");
        System.out.println(Arrays.toString(array));
    }
    /**冒泡排序
     * 冒泡排序的核心思想
     * 1.排序n-1次，每次排序都通过两辆比较和交换得到本次的最小值放到相应的位置
     * 2.第二层循环是j>i，因为前i个已经有序排列了，没必要比较和交换了
     * 3.冒泡排序可以优化，当有一次遍历排序的过程中从来没有交换过，
     * 说明次序列已经有序排序，第一层循环可以退出了，排序结束
     * @param array
     */
    private static void bubbleSort(int[] array){
        int tmp=0;
        boolean isSwapFlag = false;
        for(int i=0 ;i<array.length-1;i++){
            for(int j = array.length-1;j>i;j--){
                if(array[j-1]>array[j]){
                    //交换相邻的两个数
                    tmp = array[j-1];
                    array[j-1] = array[j];
                    array[j] = tmp;
                    isSwapFlag=true;
                }
            }
            //如果本次没有交换，说明序列已经按有序排序了
            if(!isSwapFlag){
                break;
            }
        }
    }
    /**
     * 以数组的第一个元素为关键字，比它大的排在它后边，比它小的排在它前边
     * 
     * @param array
     * @param left
     * @param right
     * @return
     */
    private static int quickDivide(int[] array ,int left ,int right){
        int base =array[left];
        while(left < right){
            while(left < right && array[right] >= base){
                right--;
            }
            //找到比关键字小的放在关键字的左边
            array[left] = array[right];
            while(left < right && array[left] <= base){
                left++;
            }
            //找到比关键字大的放在关键字的右边
            array[right] = array[left];
        }
        //left=right的时候循环退出了，left所指的位置就是关键字所在的位置
        array[left] = base;
        //返回关键字所在的下标
        return left;
    }
    /**快速排序
     * 采用递归的方式进行排序，其实采用的的是分治排序的思维方式
     * 以数组的第一个元素为关键字，比它大的排在它后边，比它小的排在它前边
     * 然后递归对关键字前后两组序列进行排序
     * @param array
     * @param left
     * @param right
     */
    private static void quickSort(int[] array ,int left ,int right){
        if (left < right){
            int base = quickDivide(array,left,right);
            quickSort(array,left,base-1);
            quickSort(array,base+1,right);
        }
    }
}