细数常见的6种排序算法，附Java代码，一文掌握！

在Java中，有多种排序算法可以用来对数组或集合进行排序。下面我们介绍几种常见的排序算法：

1.冒泡排序（Bubble Sort）：它是排序算法中最简单的一种。通过重复地交换相邻的元素，将较大的元素逐渐“冒泡”到数组的末尾。时间复杂度为O(n^2)。

2.选择排序（Selection Sort）：每次从未排序的数组中选择最小的元素，将其放在已排序部分的末尾。时间复杂度为O(n^2)。

3.插入排序（Insertion Sort）：将数组分为已排序和未排序两部分，遍历未排序部分的元素，并将其插入到已排序部分的正确位置。时间复杂度为O(n^2)。

4.快速排序（Quick Sort）：通过选择一个基准元素，将数组分为两个子数组，并对这两个子数组进行递归排序。快速排序使用分治策略，平均情况下的时间复杂度为O(n log n)，最坏情况下为O(n^2)。

5.归并排序（Merge Sort）：将数组递归地分成两半，对每一半进行排序，然后再将两个有序的子数组进行合并。归并排序的时间复杂度为O(n log n)。

6.堆排序（Heap Sort）：利用二叉堆的性质进行排序，先将数组构建成最大堆，然后依次将最大元素与数组末尾的元素交换，并重新构建最大堆。堆排序的时间复杂度为O(n log n)。

以上只是介绍了一些常见的排序算法，实际上还有其他的排序算法，如希尔排序、计数排序和基数排序等。在实际应用中，选择适合问题规模和数据特点的排序算法非常重要。此外，Java还提供了Arrays类和Collections类中的sort方法，可以方便地对数组和集合进行排序，这些方法底层会使用一些优化过的排序算法来提高性能。

接下来，请看下面的示例代码，演示如何使用Java进行排序：

import java.util.Arrays;


public class SortExample {
    public static void main(String[] args) {
        int[] array = {5, 2, 8, 1, 3};


        // 冒泡排序
        bubbleSort(array);
        System.out.println("Bubble Sort: " + Arrays.toString(array));


        // 选择排序
        selectionSort(array);
        System.out.println("Selection Sort: " + Arrays.toString(array));


        // 插入排序
        insertionSort(array);
        System.out.println("Insertion Sort: " + Arrays.toString(array));


        // 快速排序
        quickSort(array, 0, array.length - 1);
        System.out.println("Quick Sort: " + Arrays.toString(array));


        // 归并排序
        mergeSort(array, 0, array.length - 1);
        System.out.println("Merge Sort: " + Arrays.toString(array));


        // 堆排序
        heapSort(array);
        System.out.println("Heap Sort: " + Arrays.toString(array));
    }


    public static void bubbleSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            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;
                }
            }
        }
    }


    public static void selectionSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            int minIndex = 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;
        }
    }


    public static void insertionSort(int[] array) {
        int n = array.length;
        for (int i = 1; i < n; i++) {
            int key = array[i];
            int j = i - 1;
            // 将大于key的元素向后移动
            while (j >= 0 && array[j] > key) {
                array[j + 1] = array[j];
                j--;
            }
            array[j + 1] = key;
        }
    }


    public static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(array, low, high);
            quickSort(array, low, pivotIndex - 1);
            quickSort(array, pivotIndex + 1, high);
        }
    }


    private static int partition(int[] array, int low, int high) {
        int pivot = array[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (array[j] < pivot) {
                i++;
                // 交换元素
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
        // 将pivot放在正确的位置上
        int temp = array[i + 1];
        array[i + 1] = array[high];
        array[high] = temp;
        return i + 1;
    }


    public static void mergeSort(int[] array, int low, int high) {
        if (low < high) {
            int mid = (low + high) / 2;
            mergeSort(array, low, mid);
            mergeSort(array, mid + 1, high);
            merge(array, low, mid, high);
        }
    }


    private static void merge(int[] array, int low, int mid, int high) {
        int n1 = mid - low + 1;
        int n2 = high - mid;


        int[] left = new int[n1];
        int[] right = new int[n2];


        for (int i = 0; i < n1; i++) {
            left[i] = array[low + i];
        }
        for (int j = 0; j < n2; j++) {
            right[j] = array[mid + 1 + j];
        }


        int i = 0, j = 0;
        int k = low;


        while (i < n1 && j < n2) {
            if (left[i] <= right[j]) {
                array[k] = left[i];
                i++;
            } else {
                array[k] = right[j];
                j++;
            }
            k++;
        }


        while (i < n1) {
            array[k] = left[i];
            i++;
            k++;
        }


        while (j < n2) {
            array[k] = right[j];
            j++;
            k++;
        }
    }


    public static void heapSort(int[] array) {
        int n = array.length;
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(array, n, i);
        }
        for (int i = n - 1; i >= 0; i--) {
            // 将当前根节点（最大值）与末尾元素进行交换
            int temp = array[0];
            array[0] = array[i];
            array[i] = temp;
            // 重新构建最大堆
            heapify(array, i, 0);
        }
    }


    private static void heapify(int[] array, int n, int i) {
        int largest = i; // 初始化最大值为根节点
        int left = 2 * i + 1;
        int right = 2 * i + 2;


        if (left < n && array[left] > array[largest]) {
            largest = left;
        }
        if (right < n && array[right] > array[largest]) {
            largest = right;
        }


        if (largest != i) {
            // 交换节点
            int temp = array[i];
            array[i] = array[largest];
            array[largest] = temp;
            // 递归地对子树进行堆化
            heapify(array, n, largest);
        }
    }
}