经典排序算法

/**
 * 写一个排序算法 1-10随机数字 进行排序 (选择排序和冒泡排序以及快速排序)
 * 
 * @since 6.0
 * @version 2016-10-19 下午4:53:36
 * @author Benson-Home
 */
public class TestSort {


    /**
     * 快速排序（N*logN）
     * 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，
     * 再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
     * 对挖坑填数进行总结
     * 1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。
     * 2．j--由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
     * 3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。
     * 4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。
     * 
     * @param numbers
     * @param left
     * @param right
     */
    public static void quickSort(int[] numbers, int left, int right) {
        if (left < right) {
            int dp = TestSort.patition(numbers, left, right);
            System.out.println("分治下标：" + dp);
            TestSort.quickSort(numbers, left, dp - 1);
            TestSort.quickSort(numbers, dp + 1, right);
        }
    }


    // 返回基准元素位置（拆分之后基准元素左边的元素都比基准元素小，右边的元素都不小于基准元素）
    private static int patition(int[] numbers, int left, int right) {
        int i = left;
        int j = right;
        int x = numbers[i]; // 取第一个元素为基准数
        while (i < j) {
            // 从右向左查找比基准数小的数
            while (i < j && numbers[j] >= x) {
                j--;
            }
            if (i < j) {
                numbers[i] = numbers[j]; // 将s[j]填到s[i]中，s[j]就形成了一个新的坑
                i++;
            }
            // 开始从左向右找大于基准数的
            while (i < j && numbers[i] < x) {
                i++;
            }
            if (i < j) {
                numbers[j] = numbers[i];// 将s[i]填到s[j]中，s[i]就形成了一个新的坑
                j--;
            }
        }
        numbers[i] = x;
        return i;
    }


    /**
     * 选择排序（N的平方）
     * 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
     * 
     * @param numbers
     */
    public static void selSort(int[] numbers) {
        for (int k = 0; k < numbers.length - 1; k++) {
            int min = k;
            for (int j = k + 1; j < numbers.length; j++) {
                // 依次循环找出最小的下标
                if (numbers[j] < numbers[min]) {
                    min = j;
                }
            }
            // 交换位置
            if (k != min) {
                int temp = numbers[k];
                numbers[k] = numbers[min];
                numbers[min] = temp;
            }
        }
    }


    /**
     * 冒泡排序（N的平方）
     * 
     * @param numbers
     * @return
     */
    public static void bubbleSort(int[] numbers) {
        // int[] returnIntArray = new int[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            for (int j = i + 1; j < numbers.length; j++) {
                int one = numbers[i];
                int two = numbers[j];
                if (one > two) {
                    // 交换
                    numbers[i] = two;
                    numbers[j] = one;
                }
            }
        }
    }


    /**
     * @param args
     */
    public static void main(String[] args) {
        Random random = new Random();
        int[] numbers = new int[10000];
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = random.nextInt(10000);
        }
        Date dateStart = new Date();
        // TestSort.bubbleSort(numbers);
        // TestSort.selSort(numbers);
        TestSort.quickSort(numbers, 0, numbers.length - 1);
        Date dateEnd = new Date();


        for (int num : numbers) {
            System.out.println(num);
        }
        System.out.println("排序耗费时间：" + (dateEnd.getTime() - dateStart.getTime()));
    }
}