创建排序算法复杂度及稳定性总结

算法	时间复杂度	空间复杂度	稳定性
冒泡排序	O(n^2)	O(1)	稳定
插入排序	O(n^2)	O(1)	稳定
选择排序	O(n^2)	O(1)	不稳定
归并排序	O(nlogn)	O(n)	稳定
快速排序	O(nlogn)	O(logn)	不稳定
堆排序	O(nlogn)	O(1)	不稳定

目前不存在时间复杂度O(nlogn)，额外空间复杂度O(1)，又稳定的排序。

代码：

import java.util.ArrayList;

public class Order {
    public static void main(String[] args) {
        ArrayList<Integer> arr1 = new ArrayList<>();
        arr1.add(5);
        arr1.add(3);
        arr1.add(6);
        arr1.add(6);
        arr1.add(6);
        arr1.add(6);
        arr1.add(2);
        arr1.add(10);
        arr1.add(8);
        arr1.add(7);
        arr1.add(2);
        System.out.println(arr1);
//        bubbleSort(arr1);
//        insertSort(arr1);
//        selectSort(arr1);
//        mergeSort(arr1);
//        quickSort(arr1);
        heapSort(arr1);
        System.out.println(arr1);
    }

    public static void bubbleSort(ArrayList<Integer> arr) {

        for (int i = 0; i < arr.size() - 1; i++) { // 冒泡排序每次将最大的放在最右边，共需length-1 次
            for (int j = 0; j < arr.size() - i - 1; j++) {
                if (arr.get(j) > arr.get(j + 1)) {
                    // swap(arr.get(j), arr.get(j+1));
                    int temp = arr.get(j);
                    arr.set(j, arr.get(j + 1));
                    arr.set(j + 1, temp);
                }
            }
        }
    }

    public static void insertSort(ArrayList<Integer> arr) {
        for (int i = 1; i < arr.size(); i++) { //插入排序保证[0,i-1]上有序，共需length-1 次
            for (int j = i; j > 0; j--) {
                int a = arr.get(j);
                int b = arr.get(j - 1);
                if (a >= b) break;
                arr.set(j, b);
                arr.set(j - 1, a);
            }
        }
    }

    public static void selectSort(ArrayList<Integer> arr) {
        for (int i = 0; i < arr.size() - 1; i++) { // 选择排序依次选择最小的放到i位置上，共需length-1 次
            int minNum = arr.get(i);
            int minIndex = i;
            for (int j = i + 1; j < arr.size(); j++) {
                if (minNum > arr.get(j)) {
                    minNum = arr.get(j);
                    minIndex = j;
                }
            }
            arr.set(minIndex, arr.get(i));
            arr.set(i, minNum);
        }
    }


    public static void mergeSort(ArrayList<Integer> arr) {
        if (arr == null || arr.size() < 2) return;

        mergeSort(arr, 0, arr.size() - 1);
    }

    private static void mergeSort(ArrayList<Integer> arr, int left, int right) {
        if (left == right) return;
        int mid = left + ((right - left) >> 1);
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }

    private static void merge(ArrayList<Integer> arr, int l, int m, int r) {
        ArrayList<Integer> heap = new ArrayList<>();
        int p = l, q = m + 1;
        int n = 0;
        while (p <= m && q <= r) {
            if (arr.get(p) <= arr.get(q)) {
                heap.add(n++, arr.get(p++));
            } else {
                heap.add(n++, arr.get(q++));
            }
        }
        while (p <= m) {
            heap.add(n++, arr.get(p++));
        }
        while (q <= r) {
            heap.add(n++, arr.get(q++));
        }

        for (int i = 0; i < n; i++) {
            arr.set(l++, heap.get(i));
        }

    }


    public static void quickSort(ArrayList<Integer> arr) {
        if (arr == null || arr.size() < 2) return;
        quickSort(arr, 0, arr.size() - 1);
    }

    private static void quickSort(ArrayList<Integer> arr, int l, int r) {
        if (l < r) {
            // 随机选取一个数 放到最右边作为枢纽
            swap2(arr, l + (int) (Math.random() * (r - 1 - l)), r);
            ArrayList<Integer> p = partition(arr, l, r);
            quickSort(arr, l, p.get(0) - 1);
            quickSort(arr, p.get(1) + 1, r);
        }
    }

    private static ArrayList<Integer> partition(ArrayList<Integer> arr, int l, int r) {
        int less = l - 1;
        int more = r;
        while (l < more) {
            if (arr.get(l) < arr.get(r)) {
                swap2(arr, ++less, l++);
            } else if (arr.get(l) > arr.get(r)) {
                swap2(arr, --more, l);
            } else {
                l++;
            }
        }
        swap2(arr, more, r);
        ArrayList<Integer> p = new ArrayList<>();
        p.add(less + 1);
        p.add(more);
        return p;
    }


    private static void swap2(ArrayList<Integer> arr, int i, int j) {
        int temp = arr.get(i);
        arr.set(i, arr.get(j));
        arr.set(j, temp);
    }

    public static void heapSort(ArrayList<Integer> arr) {
        if (arr == null || arr.size() < 2) {
            return;
        }
        for (int i = 0; i < arr.size(); i++) {
            heapInsert(arr, i);
        }
        int size = arr.size();
        swap2(arr, 0, --size);
        while (size > 0) {
            heapify(arr, 0, size);
            swap2(arr, 0, --size);
        }

    }

    private static void heapInsert(ArrayList<Integer> arr, int i) {
        while (arr.get(i) > arr.get((i - 1) / 2)) {
            swap2(arr, i, (i - 1) / 2);
            i = (i - 1) / 2;
        }
    }

    private static void heapify(ArrayList<Integer> arr, int i, int size) {
        int left = i * 2 +1;
        while (left < size) {
           int largest = left + 1<size&& arr.get(left+1)>arr.get(left)?left+1:left;
            largest = arr.get(largest)> arr.get(i) ? largest : i;
            if (largest == i) {
                break;
            }
            swap2(arr, largest, i);
            i = largest;
            left = i * 2 + 1;
        }
    }
}