分治算法

1. 基本概念

• 核心思想：将一个复杂的问题分解为若干个规模较小、相互独立且结构与原问题相似的子问题，通过递归地解决这些子问题，最后将子问题的解合并得到原问题的解。这一思想基于递归和问题简化的原则，使得复杂问题能够逐步被解决。
• 适用场景：适用于能够分解为相似子问题，且子问题的解可以合并成原问题解的情况。例如，对大规模数据的排序、搜索，几何问题（如最近点对问题），矩阵运算等。

2. 实现步骤

• 分解（Divide）：将原问题划分为若干个规模较小的子问题。例如在归并排序中，将一个数组从中间分成两个大致相等的子数组。在C++ 中，通常通过计算索引或划分数据范围来实现，如：

int mid = left + (right - left) / 2; 

• 解决（Conquer）：递归地解决这些子问题。当子问题规模足够小时，可以直接求解。递归调用是实现这一步骤的关键，例如归并排序中对左右子数组的递归排序：

mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);

• 合并（Combine）：将子问题的解合并成原问题的解。这一步骤需要根据具体问题设计合适的合并策略，例如归并排序中合并两个有序子数组的过程：

void merge(std::vector<int>& arr, int left, int mid, int right) { 
   // 合并逻辑 
}

3. 典型案例

• 归并排序（Merge Sort）：如上述代码示例，时间复杂度为 ( O(nlogn) )，空间复杂度为 ( O(n) )。它稳定且适用于各种数据规模，尤其在对链表排序时优势明显。
• 快速排序（Quick Sort）：平均时间复杂度 ( O(nlogn) )，最坏情况下为 ( O(n^2) )。通过选择一个基准元素，将数组分为两部分，使左边部分小于基准，右边部分大于基准，然后递归地对左右两部分进行排序。空间复杂度在平均情况下为 ( O(logn) )，最坏情况下为 ( O(n) )。

int partition(std::vector<int>& arr, int low, int high) { 
   int pivot = arr[high]; 
   int i = low - 1; 
   for (int j = low; j < high; j++) { 
       if (arr[j] < pivot) { 
           i++; 
           std::swap(arr[i], arr[j]); 
       } 
   } 
   std::swap(arr[i + 1], arr[high]); 
   return i + 1; 
} 
void quickSort(std::vector<int>& arr, int low, int high) { 
   if (low < high) { 
       int pi = partition(arr, low, high); 
       quickSort(arr, low, pi - 1); 
       quickSort(arr, pi + 1, high); 
   } 
} 

• 二分查找（Binary Search）：用于在有序数组中查找特定元素。时间复杂度为 ( O(logn) )，空间复杂度为 ( O(1) )。它不断将数组分成两半，通过比较中间元素与目标元素的大小，决定在左半部分还是右半部分继续查找。

int binarySearch(const std::vector<int>& arr, int target, int low, int high) { 
   while (low <= high) { 
       int mid = low + (high - low) / 2; 
       if (arr[mid] == target) 
           return mid; 
       else if (arr[mid] < target) 
           low = mid + 1; 
       else 
           high = mid - 1; 
   } 
   return -1; 
} 

4. 优点与缺点

• 优点
  • 效率较高：对于许多问题，分治算法能达到 ( O(nlogn) ) 或更好的时间复杂度，相比一些简单的暴力算法效率有显著提升。
  • 结构清晰：基于递归的实现方式使代码结构清晰，易于理解和维护。
• 缺点
  • 空间复杂度问题：一些分治算法，如归并排序，在合并过程中需要额外的空间，可能导致较高的空间复杂度，不适用于对空间要求苛刻的场景。
  • 递归开销：递归调用会带来额外的函数调用开销，包括栈空间的使用和参数传递等，在极端情况下可能影响性能。

5. 注意事项

• 递归终止条件：必须明确定义递归的终止条件，避免无限递归导致栈溢出。
• 子问题划分：子问题的划分要合理，尽量使子问题规模大致相等，以保证算法的时间复杂度最优。
• 合并操作：合并子问题解的操作要正确且高效，否则可能影响整个算法的性能。