Java实现基本排序算法

稳定排序算法性能比较

冒泡排序代码：

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

直接插入排序代码：

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

基数排序代码：

    /**
     * 基数排序，又称桶排序
     * 
     * @param arr
     * @return
     */
    public int[] radixSort(int[] arr, int d) {
        int k = 0;
        int n = 1;
        int m = 1; // 控制键值排序依据在哪一位
        int[][] temp = new int[10][arr.length]; // 数组的第一维表示可能的余数0-9
        int[] order = new int[10]; // 数组orderp[i]用来表示该位是i的数的个数
        while (m <= d) {
            for (int i = 0; i < arr.length; i++) {
                int lsd = ((arr[i] / n) % 10);
                temp[lsd][order[lsd]] = arr[i];
                order[lsd]++;
            }
            for (int i = 0; i < 10; i++) {
                if (order[i] != 0)
                    for (int j = 0; j < order[i]; j++) {
                        arr[k] = temp[i][j];
                        k++;
                    }
                order[i] = 0;
            }
            n *= 10;
            k = 0;
            m++;
        }
        return arr;
    }

 

不稳定排序算法性能比较

选择排序代码：

    /**
     * 选择排序
     * 
     * @param arr
     * @return
     */
    public int[] selectSort(int[] arr) {
        int temp;
        for (int i = 0; i < arr.length; i++) {
            int minus = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[i])
                    minus = j;
            }
            if (minus != i) {
                temp = arr[i];
                arr[i] = arr[minus];
                arr[minus] = temp;
            }
        }
        return arr;
    }

希尔排序代码：

    /**
     * 希尔排序
     */
    public int[] shllSort(int[] arr) {
        int dk = arr.length / 2;
        while (dk >= 1) {
            for (int i = 0; i < dk; i++) {
                for (int j = i + dk; j < arr.length; j = j + dk) {
                    if (arr[j] < arr[j - dk]) {
                        int temp = arr[j];
                        int k = j;
                        while (k > i && arr[k - dk] > temp) {
                            arr[k] = arr[k - dk];
                            k = k - dk;
                        }
                        arr[k] = temp;
                    }
                }
            }
            dk = dk / 2;
        }

        return arr;
    }
}

快速排序代码：

    /**
     * 快速排序
     * 
     * @param arr
     *            待排序数组
     * @param left
     *            待排序数组左边界
     * @param right
     *            待排序数组右边界
     * @return
     */
    public int[] quickSort(int[] arr, int left, int right) {
        int temp;
        if (left < right) {
            int s = arr[left];
            int i = left;
            int j = right;
            while (true) {
                while (i + 1 < arr.length && arr[++i] < s)
                    ;
                while (j - 1 > -1 && arr[--j] > s)
                    ;
                if (i >= j)
                    break;
                else {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
            arr[left] = arr[j];
            arr[j] = s;
            quickSort(arr, left, j - 1);
            quickSort(arr, j + 1, right);
        }
        return arr;
    }

    /**
     * 快速排序第二种实现方式
     * 
     * @param arr
     *            待排序数组
     * @param left
     *            待排序数组左边界
     * @param right
     *            待排序数组右边界
     * @return
     */
    public int[] quickSort2(int[] arr, int left, int right) {
        if (left < right) {
            int key = arr[left];
            int low = left;
            int high = right;
            while (low < high) {
                while (high > low && arr[high] >= key)
                    high--;
                arr[low] = arr[high];
                while (low < high && arr[low] <= key)
                    low++;
                arr[high] = arr[low];
            }
            arr[low] = key;
            quickSort2(arr, left, low - 1);
            quickSort2(arr, low + 1, right);
        }
        return arr;
    }