常见排序算法

冒泡排序（稳定）

时间复杂度 O(n²)

public void bubbleSort(int[] arrs){
    for (int i =0; i < arrs.length - 1; i++) {
        for (int j = 0; j < arrs.length - i - 1; j++) {
            if (arrs[j] > arrs[j + 1]) {
                int tmp = arrs[j];
                arrs[j] = arrs[j + 1];
                arrs[j + 1] = tmp;
            }
        }
    }
}

如和优化？用一个count记录每次遍历交换的次数，如果不再发生交换，则说明已经有序了，提前结束。

public void bubbleSort(int[] arrs){
    for (int i =0; i < arrs.length - 1; i++) {
    	int count = 0;
        for (int j = 0; j < arrs.length - i - 1; j++) {
            if (arrs[j] > arrs[j + 1]) {
                int tmp = arrs[j];
                arrs[j] = arrs[j + 1];
                arrs[j + 1] = tmp;
                count++;
            }
        }
        if (count == 0) return;
    }
}

选择排序(不稳定)

时间复杂度 O(n²)
不稳定例子 80 80 70

public void selectSort(int[] arrs) {
    for (int i = 0; i < arrs.length; i++) {
        int min_key = i;
        for (int j = i + 1; j < arrs.length; j++) {
            if (arrs[j] < arrs[min_key])
                min_key = j;
        }
        int temp = arrs[i];
        arrs[i] = arrs[min_key];
        arrs[min_key] = temp;
    }
}

插入排序(稳定)

时间复杂度 O(n²)

public void insertSort(int[] arrs) {
    for (int i = 1; i < arrs.length; i++) {
        int key = arrs[i];
        int j = i - 1;
        while (j >= 0 && arrs[j] > key) {
            arrs[j + 1] = arrs[j];
            j--;
        }
        arrs[j + 1] = key;
    }
}

快速排序

先排序再递归
时间复杂度 O(nlogn)

public void quickSort(int[] arrs){
	quickSortCore(arrs, 0, arrs.length - 1);
}
public void quickSortCore(int[] arrs, int low, int high){
	if (low >= high) return;
	int mark = arrs[low];
	int i = low, j = high;
	
	while (i < j) {
		while (arrs[j] >= mark && i < j) j--;
		if (i < j) swap(arrs, i, j);
		while (arrs[i] <= mark && i < j) i++;
		if (i < j) swap(arrs, i, j);
	}
	quickSortCore(arrs, low, i - 1);
	quickSortCore(arrs, i + 1, high);
}

public void swap(int[] arrs, int a, int b){
	int tmp = arrs[a];
	arrs[a] = arrs[b];
	arrs[b] = tmp;
}

归并排序

先递归再排序
时间复杂度 O(nlogn)

public static int[] mergeSort(int[] arr, int start, int end) {
    if (start == end) return new int[] {arr[start]};

    int mid = (end - start) / 2 + start;
    int[] leftArr = mergeSort(arr, start, mid);
    int[] rightArr = mergeSort(arr, mid + 1, end);
    int[] newArr = new int[leftArr.length + rightArr.length];

    int m = 0, l = 0, r = 0;
    while (l < leftArr.length && r < rightArr.length) {
        newArr[m++] = leftArr[l] < rightArr[r] ? leftArr[l++] : rightArr[r++];
    }
    while (l < leftArr.length)
        newArr[m++] = leftArr[l++];
    while (r < rightArr.length)
        newArr[m++] = rightArr[r++];

    return newArr;
}