java排序大汇总（java几种排序）

1. 冒泡排序（Bubble Sort）：冒泡排序是一种简单的排序算法，它通过比较相邻两个元素的大小来进行排序。每一轮循环都会把一个最大值移动到数组的末尾，因此每一轮循环会少处理一项。冒泡排序的时间复杂度为O(n^2)。

public void bubbleSort(int[] array) {
    int n = array.length;
    for (int i = 0; i < n - 1; i++) { // 外层循环表示循环次数，共循环n-1次
        for (int j = 0; j < n - i - 1; j++) { // 内层循环表示每次循环比较的元素个数
            if (array[j] > array[j + 1]) { // 比较相邻两个元素的大小，若前者大于后者，则交换这两个元素的位置
                // 交换元素
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

2. 插入排序（Insertion Sort）：插入排序也是一种简单的排序算法，它通过将未排序的元素依次插入已排序的元素中，来完成排序。插入排序的时间复杂度为O(n^2)，但当数据已经基本有序时，插入排序的表现会更好。

public void insertionSort(int[] array) {
    int n = array.length;
    for (int i = 1; i < n; i++) { // 外层循环表示待插入的元素下标，从1开始到n-1
        int key = array[i]; // 待插入的元素
        int j = i - 1; // 已排好序部分的最后一个元素下标
        while (j >= 0 && array[j] > key) { // 在已排好序部分找到插入位置
            array[j + 1] = array[j]; // 把大于待插入元素的元素向右移动一位
            j--;
        }
        array[j + 1] = key; // 把待插入元素插入到正确的位置
    }
}

3. 选择排序（Selection Sort）：选择排序是一种简单的排序算法，它通过依次选择未排序部分中的最小值，并将其放到已排序部分的末尾，来完成排序。选择排序的时间复杂度为O(n^2)。

public void selectionSort(int[] array) {
    int n = array.length;
    for (int i = 0; i < n - 1; i++) { // 外层循环表示已排好序部分的长度，初始值为0，每次循环加1
        int minIndex = i; // 已排好序部分的最小值下标，默认为i
        for (int j = i + 1; j < n; j++) { // 内层循环表示在未排序部分找到最小值
            if (array[j] < array[minIndex]) { // 如果当前值比最小值还小，则更新最小值下标
                minIndex = j;
            }
        }
        // 交换元素
        int temp = array[i];
        array[i] = array[minIndex];
        array[minIndex] = temp;
    }
}

4. 快速排序（Quick Sort）：快速排序是一种分治排序算法，它通过选定一个主元（pivot），将数组分成两个子数组，并对子数组进行递归排序，从而完成排序。快速排序的平均时间复杂度为O(nlogn)，但是最坏的情况下的时间复杂度为O(n^2)。

public void quickSort(int[] array, int low, int high) {
    if (low < high) { // 当low >= high时停止递归
        int pivotIndex = partition(array, low, high); // 将数组分成两个子数组，并返回主元的最终位置
        quickSort(array, low, pivotIndex - 1); // 对左子数组进行递归排序
        quickSort(array, pivotIndex + 1, high); // 对右子数组进行递归排序
    }
}

private int partition(int[] array, int low, int high) {
    int pivot = array[high]; // 取数组最后一个元素为主元
    int i = low - 1; // smallerIndex表示已经处理过的元素中比主元小的下标最大值
    for (int j = low; j < high; j++) { // 遍历整个数组
        if (array[j] < pivot) { // 如果当前元素比主元小
            i++; // smallerIndex加1
            // 交换元素
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
    // 交换元素
    int temp = array[i + 1];
    array[i + 1] = array[high];
    array[high] = temp;
    return i + 1; // 返回主元的最终位置
}

5. 归并排序（Merge Sort）：归并排序也是一种分治排序算法，它通过将数组划分成两个子数组，并对子数组进行递归排序，最后将两个排序后的子数组合并成一个有序的数组。归并排序的时间复杂度为O(nlogn)。

public void mergeSort(int[] array, int low, int high) {
    if (low < high) { // 当low >= high时停止递归
        int mid = (low + high) / 2; // 找到middleIndex
        mergeSort(array, low, mid); // 对左子数组进行递归排序
        mergeSort(array, mid + 1, high); // 对右子数组进行递归排序
        merge(array, low, mid, high); // 合并两个有序子数组
    }
}

private void merge(int[] array, int low, int mid, int high) {
    int n1 = mid - low + 1; // 左子数组的长度
    int n2 = high - mid; // 右子数组的长度
    int[] leftArray = new int[n1]; // 左子数组
    int[] rightArray = new int[n2]; // 右子数组
    for (int i = 0; i < n1; ++i) {
        leftArray[i] = array[low + i]; // 把原数组中左子数组的元素复制到新数组中
    }
    for (int j = 0; j < n2; ++j) {
        rightArray[j] = array[mid + 1 + j]; // 把原数组中右子数组的元素复制到新数组中
    }
    int i = 0, j = 0;
    int k = low;
    while (i < n1 && j < n2) { // 将两个数组合并成一个有序数组
        if (leftArray[i] <= rightArray[j]) {
            array[k] = leftArray[i];
            i++;
        } else {
            array[k] = rightArray[j];
            j++;
        }
        k++;
    }
    while (i < n1) { // 把剩余的元素加到新数组中
        array[k] = leftArray[i];
        i++;
        k++;
    }
    while (j < n2) { // 把剩余的元素加到新数组中
        array[k] = rightArray[j];
        j++;
        k++;
    }
}

以上是本人手写举例，请大家给予鼓励支持！