Java - 排序算法

Java 排序算法的学习笔记

冒泡排序

思路

第0轮：遍历arr[0]到arr[n - 1]，相邻数为逆序就交换，本轮遍历最大数在arr[n - 1]位置。

第1轮：遍历arr[0]到arr[n - 2]，相邻数为逆序就交换，本轮遍历最大数在arr[n - 2]位置。

…

第n-2轮：遍历arr[0]。
冒泡排序gif演示

优化：使用标记flag，初始化为false。如果每轮发生交换，则将flag置为true。当发现flag没再变化，说明数组已经从小到大排序了，不用再进行下一轮，直接break。flag仍在变化，则在每轮结束后置回false，进行下一轮判断。

代码

class Solution {
    public static void bubbleSort(int arr[]) {
        int temp = 0;
        boolean flag = false;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if (!flag) {
                break;
            } else {
                flag = false;
            }
        }
    }
}

选择排序

思路

第0轮：遍历arr[1]到arr[n - 1]，找出其中的最小数，将最小数与arr[0]交换位置。

第1轮：遍历arr[2]到arr[n - 1]，找出其中的最小数，将最小数与arr[1]交换位置。

…

第n-2轮：遍历arr[n - 1]。
选择排序gif演示

代码

class Solution {
    public static void selectSort(int arr[]) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            int min = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {
                    min = arr[j];
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }
    }
}

希尔排序

思路

第一轮，步长gap = arr.length / 2 = 5 > 0，数组分为5组 [ 8 , 3 ]、[ 9 , 5 ]、[ 1 , 4 ]、[ 7 , 6 ]、[ 2 , 0 ]。

这5个组分别进行插入排序。得到如下图排序：

第二轮，步长gap = 5 / 2 = 2 > 0，数组分为2组 [ 3, 1, 0 , 9 , 7 ]、[ 5 , 6 , 8 , 4 , 2 ]。

这2个组分别进行插入排序。得到如下图排序：

第三轮，步长gap = 2 / 2 = 1 > 0，数组整体进行插入排序，得到如下图排序：

代码

class Solution {
    public static void shellSort(int arr[]) {
        for (int gap = arr.length / 2; gap > 0; gap = gap / 2) {
            for (int i = gap; i < arr.length; i++) {
                int j = i;
                int temp = arr[j];
                if (arr[j] < arr[j - gap]) {
                    while (j - gap >= 0 && temp < arr[j - gap]) {
                        arr[j] = arr[j - gap];
                        j = j - gap;
                    }
                    arr[j] = temp;
                }
            }
        }
    }
}

快速排序

思路

选择数组首位作为基准数temp，将小于基准数的都放在数组左半边，大于基准数的都放在数组右半边，基准数放在中间。

然后在数组左半边和数组右半边递归地进行快速排序，最后得到从小到大的有序数组。

代码思路

左右指针起始指向数组的首尾。因为数组首位是基准数，相当于数组左边空出一个位置，看右指针。只要右指针指向数大于等于temp时，该数不动，右指针左移；直到右指针指向数小于基准数，该数填入左边空出的位置，并且左指针向右移一位。

此时数组右边空出位置，看左指针。只要左指针指向数小于等于temp时，该数不动，左指针右移；直到左指针指向数大于基准数，该数填入右边空出的位置，并且右指针向左移一位。

…

当循环结束说明左指针和右指针在中间已经相遇，并且相遇的位置是一个空出的位置，填入temp即可，并将此处下标返回，作为后面数组左半边和数组右半边递归的分界点。

代码

import java.util.Arrays;
class Solution {
        public static void quickSort(int arr[], int left, int right) {
            if (left < right) {
                int temp = sort(arr, left, right);
                quickSort(arr, left, temp - 1);
                quickSort(arr, temp + 1, right);
            }
        }

        static int sort(int arr[], int left, int right) {
            int temp = arr[left];
            while (left < right) {
                while (left < right && arr[right] >= temp) {
                    right--;
                }
                if (left < right) {
                    arr[left] = arr[right];
                    left++;
                }
                while (left < right && arr[left] <= temp) {
                    left++;
                }
                if (left < right) {
                    arr[right] = arr[left];
                    right--;
                }
            }
            arr[left] = temp;
            return left;
        }

    public static void main(String[] args) {
        int[] arr = new int[]{8, 9, 1, 7, 2, 4, 6, 3, 5};
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

}

归并排序

思路

归并排序gif演示

代码

import java.util.Arrays;
class Solution {
    static void mergeSort(int arr[], int left, int right, int temp[]) {
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(arr, left, mid, temp);
            mergeSort(arr, mid + 1, right, temp);
            merge(arr, left, mid, right, temp); //每分一次就要合并一次
        }
    }

    static void merge(int arr[], int left, int mid, int right, int temp[]) {
        int i = left;
        int j = mid + 1;
        int t = 0;
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[t++] = arr[i++];
            } else {
                temp[t++] = arr[j++];
            }
        }
        while (i <= mid) {
            temp[t++] = arr[i++];
        }
        while (j <= right) {
            temp[t++] = arr[j++];
        }

        t = 0;
        int arrLeft = left;
        while (arrLeft <= right) {
            arr[arrLeft++] = temp[t++];
        }
    }

    public static void main(String[] args) {
        int[] arr = new int[]{8, 9, 1, 7, 2, 4, 6, 3, 5};
        int temp[] = new int[arr.length];
        mergeSort(arr, 0, arr.length - 1, temp);
        System.out.println(Arrays.toString(arr));
    }
}

各种排序的比较

	平均时间复杂度	空间复杂度	稳定性
冒泡排序	O(n^2)	O(1)	稳定
选择排序	O(n^2)	O(1)	不稳定
希尔排序	O(nlogn)	O(1)	不稳定
快速排序	O(nlogn)	O(nlogn)	不稳定
归并排序	O(nlogn)	O(n)	稳定
堆排序	O(nlogn)	O(1)	不稳定