排序算法（java）

1. 快速排序

在快速排序算法中，首先我们检查数组是否为空或者长度为零。如果是，就直接返回。接下来调用 quickSort() 方法进行快速排序。quickSort() 方法是一个递归方法，它首先调用 partition() 方法找到分割点，然后分别递归调用 quickSort() 方法来排序分割点左边的元素和右边的元素。

partition() 方法首先选择中间的元素作为主元（pivot），然后从数组的左边和右边开始扫描，交换不正确的元素，直到左指针超过了右指针。在这个过程中，左指针找到一个大于主元的元素，右指针找到一个小于主元的元素，然后交换它们，直到左指针超过了右指针。最后，返回左指针，作为下一次分割的起点。

public class QuickSort {

    public static void sort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        quickSort(arr, 0, arr.length - 1);
    }

    private static void quickSort(int[] arr, int left, int right) {
        int index = partition(arr, left, right);
        if (left < index - 1) {
            quickSort(arr, left, index - 1);
        }
        if (index < right) {
            quickSort(arr, index, right);
        }
    }

    private static int partition(int[] arr, int left, int right) {
        int pivot = arr[(left + right) / 2];
        while (left <= right) {
            while (arr[left] < pivot) {
                left++;
            }
            while (arr[right] > pivot) {
                right--;
            }
            if (left <= right) {
                int temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
                left++;
                right--;
            }
        }
        return left;
    }
}

2. 归并排序

在归并排序算法中，首先我们检查数组是否为空或者长度为零。如果是，就直接返回。接下来调用 mergeSort() 方法进行归并排序。mergeSort() 方法是一个递归方法，它首先将数组分成左右两个部分，然后分别递归调用 mergeSort() 方法来排序左半部分和右半部分。最后，调用 merge() 方法将排好序的左半部分和右半部分归并在一起。

merge() 方法创建一个临时数组来存储归并的结果，然后使用三个指针 i、j、k 来分别指向左半部分、右半部分和临时数组。接下来，比较左半部分的元素和右半部分的元素，将较小的元素放入临时数组中，然后将相应的指针向后移动一位。当其中一个指针到达边界时，就将另一个指针剩余的元素全部放入临时数组中。最后，将临时数组中的元素复制回原数组的相应位置。

public class MergeSort {

    public static void sort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        mergeSort(arr, 0, arr.length - 1);
    }

    private static void mergeSort(int[] arr, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);
            merge(arr, left, mid, right);
        }
    }

    private static void merge(int[] arr, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];
        int i = left, j = mid + 1, k = 0;
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = arr[i++];
        }
        while (j <= right) {
            temp[k++] = arr[j++];
        }
        for (int p = 0; p < temp.length; p++) {
            arr[left + p] = temp[p];
        }
    }
}

3. 冒泡排序

在冒泡排序算法中，我们首先检查数组是否为空或者长度为零。如果是，就直接返回。接下来，我们使用两个嵌套循环，外循环控制排序的轮数，内循环控制每轮比较的次数。在每一轮中，我们比较相邻的元素，如果前一个元素比后一个元素大，则交换它们的位置。这样，每一轮比较后，最大的元素就会“浮”到数组的末尾，下一轮比较时就可以少比较一次。

注意，我们在内循环中的比较次数是 n - 1 - i，其中 n 是数组的长度，i 是当前排序的轮数。这是因为在每一轮中，我们都可以将最大的元素排在数组的末尾，所以下一轮就可以少比较一次。

public class BubbleSort {

    public static void sort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}