JAVA排序算法

public class Sort {

    public static void main(String[] args) {

        int[] arr = new int[10];
        for (int i = 0; i < 10; i++)
            arr[i] = (int) (Math.random() * 100);

        bubbleSort(arr);

        for (int i = 0; i < arr.length; i++)
            System.out.print(arr[i] + " ");

    }

    /**
     * 堆排序
     * 时间复杂度：O(nlogn)
     * 空间复杂度：O(1)
     * 稳定性：NO
     *
     * @param arr
     */
    private static void heapSort(int[] arr) {

        int n = arr.length;
        if (n == 0)
            return;

        for (int i = (n - 2) >> 1; i >= 0; i--)
            sink(i, n - 1, arr);

        for (int i = n - 1; i > 0; i--) {
            swap(i, 0, arr);
            sink(0, i - 1, arr);
        }

    }

    private static void sink(int pos, int end, int[] arr) {

        if (end < pos * 2 + 1)
            return;

        int swapPos = -1;
        if (end == pos * 2 + 1 && arr[pos] < arr[pos * 2 + 1])
            swapPos = pos * 2 + 1;
        else if (end >= pos * 2 + 2 && arr[pos] < arr[pos * 2 + 1] && arr[pos * 2 + 1] > arr[pos * 2 + 2])
            swapPos = pos * 2 + 1;
        else if (end >= pos * 2 + 2 && arr[pos] < arr[pos * 2 + 2] && arr[pos * 2 + 1] <= arr[pos * 2 + 2])
            swapPos = pos * 2 + 2;

        if (swapPos != -1) {
            swap(pos, swapPos, arr);
            sink(swapPos, end, arr);
        }

    }


    /**
     * 快速排序
     * 时间复杂度：O(nlogn)
     * 空间复杂度：O(logn)
     * 稳定性：NO
     *
     * @param arr
     */
    private static void quickSort(int[] arr) {

        quickSort(0, arr.length - 1, arr);

    }

    private static void quickSort(int begin, int end, int[] arr) {

        if (begin >= end)
            return;

        int pos = begin;

        int beginPos = begin;
        int endPos = end;
        while (beginPos < endPos) {
            while (arr[beginPos] <= arr[pos] && beginPos < end) beginPos++;
            while (arr[endPos] > arr[pos] && endPos > begin) endPos--;
            if (beginPos < endPos)
                swap(beginPos, endPos, arr);
        }

        swap(pos, endPos, arr);
        pos = endPos;
        quickSort(begin, pos - 1, arr);
        quickSort(pos + 1, end, arr);

    }


    /**
     * 归并排序
     * 时间复杂度：O(nlogn)
     * 空间复杂度：O(n)
     * 空间复杂度在全局定义辅助数组mergeArr的时候为n，本例子中实际空间复杂度为nlogn
     * 稳定性：YES
     *
     * @param arr
     */
    private static void mergeSort(int[] arr) {

        int[] mergeArr = new int[arr.length];
        mergeSort(0, arr.length - 1, arr, mergeArr);

    }

    private static void mergeSort(int begin, int end, int[] arr, int[] mergeArr) {

        if (begin >= end)
            return;

        int middle = (end + begin) >> 1;
        mergeSort(begin, middle, arr, mergeArr);
        mergeSort(middle + 1, end, arr, mergeArr);

        int left = begin;
        int right = middle + 1;

        for (int i = begin; i <= end; i++)
            if (left >= middle + 1) mergeArr[i] = arr[right++];
            else if (right >= end + 1) mergeArr[i] = arr[left++];
            else if (arr[left] <= arr[right]) mergeArr[i] = arr[left++];
            else mergeArr[i] = arr[right++];

        for (int i = begin; i <= end; i++)
            arr[i] = mergeArr[i];

    }

    /**
     * 希尔排序
     * 时间复杂度：O(n1.3)
     * 空间复杂度：O(1)
     * 稳定性：NO
     *
     * @param arr
     */
    private static void shellSort(int[] arr) {

        int n = arr.length;
        if (n == 0)
            return;

        for (int k = 15; k >= 1; k = (k - 1) >> 1)
            for (int i = k; i < n; i += k)
                for (int j = i; j > 0; j -= k)
                    if (arr[j] < arr[j - k])
                        swap(j, j - k, arr);

    }


    /**
     * 插入排序
     * 时间复杂度：O(n2)
     * 空间复杂度：O(1)
     * 稳定性：YES
     *
     * @param arr
     */
    private static void insertSort(int[] arr) {

        int n = arr.length;
        if (n == 0)
            return;

        for (int i = 1; i < n; i++)
            for (int j = i; j > 0; j--)
                if (arr[j] < arr[j - 1])
                    swap(j, j - 1, arr);

    }

    /**
     * 选择排序
     * 时间复杂度：O(n2)
     * 空间复杂度：O(1)
     * 稳定性：NO
     *
     * @param arr
     */
    private static void selectSort(int[] arr) {

        int n = arr.length;
        if (n == 0)
            return;

        for (int i = 0; i < n; i++) {
            int lower = i;
            for (int j = i; j < n; j++)
                lower = arr[j] < arr[lower] ? j : lower;
            swap(lower, i, arr);
        }
    }

    /**
     * 冒泡排序
     * 时间复杂度：O(n2)
     * 空间复杂度：O(1)
     * 稳定性：YES
     *
     * @param arr
     */
    private static void bubbleSort(int[] arr) {

        int n = arr.length;
        if (n == 0)
            return;

        for (int i = 0; i < n; i++)
            for (int j = 0; j < n - 1 - i; j++)
                if (arr[j] > arr[j + 1])
                    swap(j, j + 1, arr);

    }


    /**
     * 交换
     *
     * @param i1
     * @param i2
     * @param arr
     */
    private static void swap(int i1, int i2, int[] arr) {

        if (i1 == i2)
            return;

        arr[i1] = arr[i2] ^ arr[i1];
        arr[i2] = arr[i1] ^ arr[i2];
        arr[i1] = arr[i1] ^ arr[i2];

    }

}