Java 排序算法

仅用于巩固基础知识

import java.util.Date;

/**
 * 排序算法
 *
 * zkh
 * 2019年9月24日 下午3:43:51
 */
public class 排序算法 {

    /**
     * 冒泡排序--1
     */
    private static int[] bubbleSort(int n) {
        int[] a = array(n);
        int size = a.length, temp;
        long start = new Date().getTime();
        for (int i = 0; i < size; i++) {
            for (int j = i + 1; j < size; j++) {
                if (a[j] > a[i]) {
                    temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
        long end = new Date().getTime();
        System.out.println("冒泡排序" + n + "条数据用时：" + (end - start) + "毫秒");
        return a;
    }

    /**
     * 选择排序--2
     *
     * 描述1：选择排序是一种简单直观的排序方法，每次寻找序列中的最小值，然后放在最末尾的位置
     * 描述2：在未排序序列中找到最小元素，存放到排序序列的起始位置再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。
     * 以此类推，直到所有元素均排序完毕。
     */
    private static int[] selectSort(int n) {
        int[] a = array(n);
        int size = a.length, k, temp;
        long start = new Date().getTime();
        for (int i = 0; i < size; i++) {
            k = i;
            for (int j = i + 1; j < size; j++) {
                if (a[j] > a[k]) {
                    k = j;
                }
            }
            temp = a[i];
            a[i] = a[k];
            a[k] = temp;
        }
        long end = new Date().getTime();
        System.out.println("选择排序" + n + "条数据用时：" + (end - start) + "毫秒");
        return a;

    }

    /**
     * 插入排序--3
     *
     * 描述1：插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。其具体步骤参见代码及注释。
     * 描述2：插入排序
     * 从第一个元素开始，该元素可以认为已经被排序
     * 取出下一个元素，在已经排序的元素序列中从后向前扫描
     * 如果该元素（已排序）大于新元素，将该元素移到下一位置
     * 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
     * 将新元素插入到该位置中
     * 重复步骤2
     */
    private static int[] inserSort(int n) {
        int[] a = array(n);
        int size = a.length, temp, j;
        long start = new Date().getTime();
        for (int i = 1; i < size; i++) {
            temp = a[i];
            for (j = i; j > 0 && temp > a[j - 1]; j--) {
                a[j] = a[j - 1];
            }
            a[j] = temp;
        }
        long end = new Date().getTime();
        System.out.println("插入排序" + n + "条数据用时：" + (end - start) + "毫秒");
        return a;
    }

    /**
     * 快速排序
     *
     * 描述1：快速排序使用分治法策略来把一个序列分为两个子序列。
     * 描述2：从数列中挑出一个元素，称为“基准”
     * 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，
     * 该基准是它的最后位置。这个称为分割（partition）操作。
     * 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。
     */
    public static int[] quickSort(int n) {
        int[] a = array(n);
        long start = new Date().getTime();
        _quickSort(a, 0, a.length - 1);
        long end = new Date().getTime();
        System.out.println("快速排序" + n + "条数据用时：" + (end - start) + "毫秒");
        return a;
    }

    public static void _quickSort(int[] a, int start, int end) {
        if (start < end) {
            int base = a[start]; // 选定的基准值（第一个数值作为基准值）
            int temp; // 记录临时中间值
            int i = start, j = end;
            do {
                while ((a[i] > base) && (i < end))
                    i++;
                while ((a[j] < base) && (j > start))
                    j--;
                if (i <= j) {
                    temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                    i++;
                    j--;
                }
            } while (i <= j);
            if (start < j)
                _quickSort(a, start, j);
            if (end > i)
                _quickSort(a, i, end);
        }
    }


    /**测试===============================================================*/
    /**
     * 枚举排序方法
     */
    private enum Type {
        // 1-冒泡排序，2-选择排序，3-插入排序，4-快速排序，5-归并排序
        MAOPAO, XUANZE, CHARU, KUAISU, GUIBING
    }

    /**
     * 用随机数获得指定长度的数组
     */
    private static int[] array(int n) {
        int[] a = new int[n];
        for (int i = 0; i < n; i++)
            a[i] = (int) Math.round((Math.random() * n));
        return a;
    }

}