数据结构与算法——排序(Java)

1.冒泡排序

平均时间复杂度O(n²)

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 tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}

2.选择排序

每次遍历，选择出第n小的元素，与n-1的元素交换
其中i为待交换的元素下表，j为最小值的下标
平均时间复杂度O(n²)

public static void selectSort(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        int minInx = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minInx]){
                minInx = j;
            }
        }
        int tmp = arr[i];
        arr[i] = arr[minInx];
        arr[minInx] = tmp;
    }
}

3.插入排序

每次遍历选择第i个元素，将其插入到前i+1个元素中合适的位置
时间复杂度O(n²)

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

4.希尔排序(缩小增量排序)

高级插入排序，平均时间复杂度O(n^1.3)
1.选定一个增长量h，按照增长量h对数据进行分组
2.对每一组进行插入排序
3.减小增长量直到1，重复2
初始                       [9  1  2  5  7  4  8  6  3  5]
h = 5 第一趟排序 [9  1  2  5  7  4  8  6  3  5]
排序后                   [4  1  2  3  5  9  8  6  5  7]
h = 2 第二趟排序 [4  1  2  3  5  9  8  6  5  7]
排序后                   [2  1  4  3  5  6  5  7  8  9]
h = 1 第三趟排序  [2  1  4  3  5  6  5  7  8  9]
排序后                   [1  2  3  4  5  5  6  7  8  9]

public static void shellsSort(int[] arr) {
    int h = arr.length / 2;
    while (h >= 1) {
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j >= h; j -= h) {
                if (arr[j - h] > arr[j]){
                    int tmp = arr[j - h];
                    arr[j - h] = arr[j];
                    arr[j] = tmp;
                } else {
                    break;
                }
            }
        }
        h /= 2;
    }
}

5.归并排序

使用分治思想：分组直到每一个单独数字 -> 合并
使用空间换时间，时间复杂度O(nlogn)

public static int[] tmp;  // 临时数组
public static void mergeSort(int[] arr) {
    tmp = new int[arr.length];
    mergeSort(arr, 0, arr.length - 1);
}

public static void mergeSort(int[] arr, int low, int high) {
    if (high <= low){
        return;
    }
    int median = low + (high - low) / 2;
    mergeSort(arr, low, median);
    mergeSort(arr, median + 1, high);
    merge(arr, low, median, high);
}

// 通过三个指针，分别指向临时数组、小数组、大数组
public static void merge(int[] arr, int low, int median, int high) {
    int i = low;
    int p1 = low;
    int p2 = median + 1;
    while (p1 <= median && p2 <= high) {
        if (arr[p1] <= arr[p2]) {
            tmp[i++] = arr[p1++];
        } else {
            tmp[i++] = arr[p2++];
        }
    }
    while (p1 <= median) {
        tmp[i++] = arr[p1++];
    }
    while (p2 <= median) {
        tmp[i++] = arr[p2++];
    }
    if (high + 1 - low >= 0){
        System.arraycopy(tmp, low, arr, low, high + 1 - low);
    }
}

6.快速排序

优化冒泡排序
1.设置分界值，将数组分组
2.大于分界值放到左边，小于的放到右边
3.递归排序左数组和右数组
等分时的时间复杂度O(nlogn)，每次选择最大/最小值时间复杂度O(n²)
归并排序和快速排序的区别
归并排序：等分
快速排序：不等分

public static void quickSort(int[] arr) {
    quickSort(arr, 0, arr.length - 1);
}

public static void quickSort(int[] arr, int low, int high) {
    if (low > high) {
        return;
    }
    int partition = partition(arr, low, high);
    quickSort(arr, low, partition - 1);
    quickSort(arr, partition + 1, high);
}

public static int partition(int[] arr, int low, int high) {
    int key = arr[low];
    int left = low;
    int right = high + 1;
    while (true) {
        while (arr[++left] < key && left != high);
        while (arr[--right] > key && right != low);
        if (left >= right) {
            break;
        } else {
            swap(arr, left, right);
        }
    }
    swap(arr, low, right);
    return right;
}

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

未完待续：堆排序，计数排序，桶排序，基数排序

排序算法总结

稳定性：相等元素次序不变

算法	平均时间复杂度	最好情况	最坏情况	辅助空间	稳定性
冒泡排序	O(n2)	O(n)	O(n2)	O(1)	稳定
选择排序	O(n2)	O(n2)	O(n2)	O(1)	不稳定
插入排序	O(n2)	O(n)	O(n2)	O(1)	稳定
希尔排序(插入)	O(n1.3)	O(n)	O(n2)	O(1)	不稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定
快速排序(冒泡)	O(nlogn)	O(nlogn)	O(n2)	O(nlogn)	不稳定
堆排序(选择)
计数排序
桶排序
基数排序