数据结构-6种常见排序算法

排序算法是计算机科学中非常基础且重要的一部分。每种算法都有自己的特点和适用场景。下面将简要介绍你所列出的六种排序算法，并给出每种算法的Java实现代码。

冒泡排序 (Bubble Sort)

冒泡排序是最简单的排序算法之一，通过重复地遍历要排序的数组，比较每对相邻元素，如果它们的顺序错误就把它们交换过来。

public void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换 arr[j+1] 和 arr[j]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

选择排序 (Selection Sort)

选择排序算法将数组分为已排序段和未排序段，并不断地选择未排序段中的最小（或最大）元素放到已排序段的末尾。

public void selectionSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }
        // 交换第 i 个元素和最小元素
        int temp = arr[min_idx];
        arr[min_idx] = arr[i];
        arr[i] = temp;
    }
}

插入排序 (Insertion Sort)

插入排序的工作方式类似于我们排序扑克牌。它将数组分为已排序段和未排序段，并不断地将未排序段的元素插入到已排序段的正确位置。

public void insertionSort(int[] arr) {
    int n = arr.length;
    for (int i = 1; i < n; ++i) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

快速排序 (Quick Sort)

快速排序是一种分治策略的排序算法，它通过选择一个“基准”元素，然后将数组分为两个子数组，一个包含小于基准的元素，另一个包含大于基准的元素，并递归地排序这两个子数组。

public void quickSort(int[] arr, int begin, int end) {
    if (begin < end) {
        int partitionIndex = partition(arr, begin, end);
        quickSort(arr, begin, partitionIndex-1);
        quickSort(arr, partitionIndex+1, end);
    }
}

private int partition(int[] arr, int begin, int end) {
    int pivot = arr[end];
    int i = (begin - 1);
    for (int j = begin; j < end; j++) {
        if (arr[j] <= pivot) {
            i++;
            int swapTemp = arr[i];
            arr[i] = arr[j];
            arr[j] = swapTemp;
        }
    }
    int swapTemp = arr[i + 1];
    arr[i + 1] = arr[end];
    arr[end] = swapTemp;
    return i + 1;
}

归并排序 (Merge Sort)

归并排序是另一种递归排序算法，它采用分治策略，将数组分成两半，对它们分别进行排序，然后将排序好的两半合并在一起。

public void mergeSort(int[] arr, int l, int r) {
    if (l < r) {
        // 找到中点
        int m = (l + r) / 2;
        // 分治递归排序
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
        // 合并结果
        merge(arr, l, m, r);
    }
}

private void merge(int[] arr, int l, int m, int r) {
    // 找出左右子数组的大小
    int n1 = m - l + 1;
    int n2 = r - m;

    // 创建临时数组
    int[] L = new int[n1];
    int[] R = new int[n2];

    // 复制数据到临时数组
    System.arraycopy(arr, l, L, 0, n1);
    System.arraycopy(arr, m + 1, R, 0, n2);

    // 合并临时数组
    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    // 复制剩余元素
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

堆排序 (Heap Sort)

堆排序利用了最大堆的性质，即父节点的值总是大于其子节点的值。通过构建最大堆，并不断移除最大元素至数组末尾，从而达到排序效果。

public void heapSort(int[] arr) {
    int n = arr.length;

    // 构建最大堆
    for (int i = n / 2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }

    // 一个个从堆顶取出元素
    for (int i = n - 1; i > 0; i--) {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        heapify(arr, i, 0);
    }
}

void heapify(int[] arr, int n, int i) {
    int largest = i; // 初始化最大为根
    int l = 2 * i + 1;
    int r = 2 * i + 2;

    // 如果左子树大于根
    if (l < n && arr[l] > arr[largest]) {
        largest = l;
    }

    // 如果右子树大于当前最大
    if (r < n && arr[r] > arr[largest]) {
        largest = r;
    }

    // 如果最大不是根
    if (largest != i) {
        int swap = arr[i];
        arr[i] = arr[largest];
        arr[largest] = swap;
        // 递归地定义子堆
        heapify(arr, n, largest);
    }
}

以上是六种常见排序算法的简单Java实现。每种算法都有其特点，选择时应根据具体情况和需求来决定使用哪一种。例如，归并排序和堆排序具有O(n log n)的最坏情况时间复杂度，而冒泡排序、选择排序和插入排序则在最坏情况下具有O(n^2)的时间复杂度。快速排序虽然在最坏情况下也是O(n^2)，但在实践中由于其较低的比较和交换次数，往往表现得非常好。