常用算法-分治算法

---

🔷 归并排序 (Merge Sort)

• 特点:

  • 基于分治策略。
  • 将问题分解为几个子问题，然后递归解决子问题，并将子问题的解合并得到原问题的解。
  • 数组被递归地分为两半，直到子数组的大小为1。

• 优点:

  • 时间复杂度始终为 (O(n \log n))。
  • 稳定排序算法。
  • 对于链表排序，归并排序的性能优于其他排序算法。

• 缺点:

  • 需要额外的存储空间 (O(n))。
  • 对于较小的数组，其他算法如插入排序可能会更快。

示例:

public static void mergeSort(int[] array, int left, int right) {
    if (left < right) {
        int middle = (left + right) / 2;
        mergeSort(array, left, middle);
        mergeSort(array, middle + 1, right);
        merge(array, left, middle, right);
    }
}

public static void merge(int[] array, int left, int middle, int right) {
    int n1 = middle - left + 1;
    int n2 = right - middle;

    int[] leftArray = new int[n1];
    int[] rightArray = new int[n2];

    for (int i = 0; i < n1; i++)
        leftArray[i] = array[left + i];
    for (int j = 0; j < n2; j++)
        rightArray[j] = array[middle + 1 + j];

    int i = 0, j = 0;
    int k = left;
    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++;
    }
}

---

🔷 快速排序 (Quick Sort)

• 特点:

  • 采用分治策略。
  • 选择一个“枢轴”元素，然后将数组划分为两个子数组，一个包含小于枢轴的元素，另一个包含大于枢轴的元素。
  • 递归地对子数组进行快速排序。

• 优点:

  • 平均和最佳情况下的时间复杂度为 (O(n \log n))。
  • 在实际排序中通常比其他 (O(n \log n)) 的排序算法更快。
  • 可以在原地排序，不需要额外的存储空间。

• 缺点:

  • 最坏情况下的时间复杂度为 (O(n^2))。
  • 枢轴的选择和数组的初始顺序对性能有影响。
  • 不是稳定的排序算法。

示例:

public static void quickSort(int[] array, int low, int high) {
    if (low < high) {
        int pivot = partition(array, low, high);
        quickSort(array, low, pivot - 1);
        quickSort(array, pivot + 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 swapTemp = array[i];
            array[i] = array[j];
            array[j] = swapTemp;
        }
    }
    int swapTemp = array[i + 1];
    array[i + 1] = array[high];
    array[high] = swapTemp;
    return i + 1;
}

⚠️ 注意: 分治算法是一种解决问题的技巧，它将问题分解为更小的、更容易解决的子问题，然后将子问题的解合并以得到原问题的解。