基本排序代码

基本排序程序代码

public class SortArray {

    /**
     * 快速排序
     *
     * @param arr
     */
    public static void quickSort(int[] arr) {
        parseQuickSort(arr, 0, arr.length - 1);
    }

    /**
     * 快排的递归操作
     *
     * @param arr
     * @param lBound
     * @param rBound
     */
    private static void parseQuickSort(int[] arr, int lBound, int rBound) {
        if (lBound < rBound) {
            int interval = quickRecursionSort(arr, lBound, rBound);
            parseQuickSort(arr, lBound, interval - 1); //左半部分 排序
            parseQuickSort(arr, interval + 1, rBound); //右半部分 排序
        }
    }

    /**
     * 快速排序
     *
     * @param arr
     */
    private static int quickRecursionSort(int[] arr, int lBound, int rBound) {
        int pivotKey = arr[lBound];
        int l = lBound;
        int r = rBound;
        while (l < r) {
            while (l < r && arr[r] >= pivotKey) r--;
            arr[l] = arr[r];
            while (l < r && arr[l] <= pivotKey) l++;
            arr[r] = arr[l];
        }
        arr[l] = pivotKey;
        return l;
    }

    /**
     * 归并排序
     *
     * @param arr
     */
    public static void mergeSort(int[] arr) {
        int[] doneArr = parseMergeArray(arr, 0, arr.length - 1);
        System.arraycopy(doneArr, 0, arr, 0, doneArr.length);
    }

    /**
     * 归并排序的递归操作
     *
     * @param arr
     * @return
     */
    private static int[] parseMergeArray(int[] arr, int lBound, int rBound) {
        if (lBound == rBound) {
            return new int[]{arr[lBound]};
        }
        int mid = lBound + (rBound - lBound) / 2;
        int[] lArr = parseMergeArray(arr, lBound, mid);
        int[] rArr = parseMergeArray(arr, mid + 1, rBound);
        return mergeRecursionSort(lArr, rArr);
    }

    /**
     * 归并排序
     *
     * @param lArr
     * @param rArr
     * @return
     */
    private static int[] mergeRecursionSort(int[] lArr, int[] rArr) {
        int[] result = new int[lArr.length + rArr.length];
        int l = 0, r = 0, k = 0;
        while (l < lArr.length && r < rArr.length) {
            result[k++] = lArr[l] < rArr[r] ? lArr[l++] : rArr[r++];
        }
        while (l < lArr.length) result[k++] = lArr[l++];
        while (r < rArr.length) result[k++] = rArr[r++];
        return result;
    }

    /**
     * 桶排序
     *
     * @param arr
     */
    private static void bucketSort(int[] arr) {
        //TODO:暂未完成
    }

    /**
     * 基数排序
     *
     * @param arr
     */
    public static void radixSort(int[] arr) {
        int[] result = new int[arr.length];
        int[] count = new int[10001];
        for (int i = 0; i < 5; i++) {
            int division = (int) Math.pow(10, i);
            for (int j = 0; j < arr.length; j++) {
                int num = arr[j] / division % 10;
                count[num]++;
            }

            for (int m = 1; m < count.length; m++) {
                count[m] = count[m] + count[m - 1];
            }

            for (int n = arr.length - 1; n >= 0; n--) {
                int num = arr[n] / division % 10;
                result[--count[num]] = arr[n];
            }

            System.arraycopy(result, 0, arr, 0, arr.length);
            Arrays.fill(count, 0);
        }
    }

    /**
     * 计数排序
     *
     * @param arr
     */
    public static void countSort(int[] arr) {
        //注意数组长度是 10   因为最大值是 10
        int[] count = new int[10001];

        //计数 [以当数组中的下标作为原来数组中的值，当前数组的值作为原来数组值的个数]
        for (int i = 0; i < arr.length; i++) {
            count[arr[i]]++;
        }

        //将计好的依次放入数组
        for (int i = 0, j = 0; i < count.length; i++) {
            while (count[i]-- > 0) arr[j++] = i;
        }
    }

    /**
     * 希尔排序
     *
     * @param arr
     */
    public static void shellSort(int[] arr) {
        int len = arr.length;
        int h = 1;
        //获取适合的间隔 据说这样取最好
        while (h < len / 3) h = 3 * h + 1;
        while (h >= 1) {
            for (int i = h; i < arr.length; i++) {
                int temp = arr[i];
                int j = i;
                for (; j >= h && temp < arr[j - h]; j -= h) {
                    arr[j] = arr[j - h];
                }
                arr[j] = temp;
            }
            h /= 3;
        }
    }

    /**
     * 插入排序
     *
     * @param arr
     */
    public static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int temp = arr[i];
            int j = i;
            for (; j > 0 && temp < arr[j - 1]; j--) {
                arr[j] = arr[j - 1];
            }
            arr[j] = temp;
        }
    }

    /**
     * 冒泡排序
     *
     * @param arr
     */
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

    /**
     * 选择排序
     *
     * @param arr
     */
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int min = i;
            for (int j = i; j < arr.length; j++) {
                min = arr[min] > arr[j] ? j : min;
            }
            int temp = arr[min];
            arr[min] = arr[i];
            arr[i] = temp;
        }
    }

}

排序检测代码

public class RandomArray {

    public static void main(String[] args) {
        check();
    }

    /**
     * 检测程序是否正确
     */
    public static void check(){
        boolean same = true;
        for (int i = 0; i < 10000; i++) {
            int[] arr = generateRandomArray();
            int[] doArr = new int[arr.length];
            System.arraycopy(arr,0,doArr,0,arr.length);
            Arrays.sort(arr);
            SortArray.quickSort(doArr);

            /*
            SortArray.selectSort(doArr);
            SortArray.bubbleSort(doArr);
            SortArray.insertSort(doArr);
            SortArray.shellSort(doArr);
            SortArray.quickSort(doArr);
            SortArray.mergeSort(doArr);
            SortArray.countSort(doArr);
            SortArray.radixSort(doArr);
             */
            for (int j = 0; j < doArr.length; j++) {
                if(arr[j]!=doArr[j]) same = false;
            }
           if(!same){
               System.out.println("出现错误："+Arrays.toString(doArr));
               break;
           }
        }
        if(same){
            System.out.println("排序正确");
        }
    }
    
    /**
     * 生成随机数组
     * @return
     */
    public static int[] generateRandomArray(){
        Random r = new Random();

        int[] arr = new int[1000];

        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt(10000);
        }
        return arr;
    }
}