算法入门---分治算法详解（C++实现）-CSDN博客

本文链接：https://blog.csdn.net/jay_515/article/details/149194169

分治算法是解决复杂问题的强大武器，本文将带你从零开始掌握分治算法的核心思想与实现技巧

一、什么是分治算法？

分治算法（Divide and Conquer）是一种重要的算法设计策略，其核心思想可以概括为三个步骤：

分解（Divide）：将原问题划分为若干个规模较小的相同类型的子问题
解决（Conquer）：递归地解决这些子问题（若子问题足够小则直接求解）
合并（Combine）：将子问题的解合并得到原问题的解

这种"分而治之"的策略，使得我们可以用简洁优雅的方式解决许多复杂问题。

二、分治算法的基本框架

ResultType divideConquer(Problem problem) {
    // 1. 递归终止条件：问题足够小，直接求解
    if (problem.size <= BASE_SIZE) {
        return solveDirectly(problem);
    }
    
    // 2. 分解原问题为若干子问题
    vector<SubProblem> subProblems = divide(problem);
    
    // 3. 递归求解子问题
    vector<ResultType> subResults;
    for (auto sub : subProblems) {
        subResults.push_back(divideConquer(sub));
    }
    
    // 4. 合并子问题的解
    return combine(subResults);
}

三、经典分治算法实例

1. 归并排序（Merge Sort）

归并排序是分治思想的完美体现：

// 合并两个有序数组
void merge(vector<int>& arr, int left, int mid, int right) {
    vector<int> temp(right - left + 1);
    int i = left, j = mid + 1, k = 0;
    
    // 合并两个有序区间
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) 
            temp[k++] = arr[i++];
        else 
            temp[k++] = arr[j++];
    }
    
    // 处理剩余元素
    while (i <= mid) temp[k++] = arr[i++];
    while (j <= right) temp[k++] = arr[j++];
    
    // 拷贝回原数组
    for (int p = 0; p < k; p++) {
        arr[left + p] = temp[p];
    }
}

// 归并排序主函数
void mergeSort(vector<int>& arr, int left, int right) {
    // 递归终止条件：区间长度<=1
    if (left >= right) return;
    
    int mid = left + (right - left) / 2;
    
    // 分解：递归排序左右子区间
    mergeSort(arr, left, mid);    // 排序左半部分
    mergeSort(arr, mid + 1, right); // 排序右半部分
    
    // 合并：合并两个有序区间
    merge(arr, left, mid, right);
}

时间复杂度分析：O(n log n)

2. 快速排序（Quick Sort）

快速排序是另一种基于分治的经典排序算法：

// 划分函数
int partition(vector<int>& arr, int left, int right) {
    int pivot = arr[right];  // 选择最后一个元素作为基准
    int i = left - 1;        // 指向小于基准的最后一个元素
    
    for (int j = left; j < right; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[right]);
    return i + 1;
}

// 快速排序主函数
void quickSort(vector<int>& arr, int left, int right) {
    if (left < right) {
        // 划分：获取基准位置
        int pivotIndex = partition(arr, left, right);
        
        // 递归排序子数组
        quickSort(arr, left, pivotIndex - 1);  // 排序左子数组
        quickSort(arr, pivotIndex + 1, right); // 排序右子数组
    }
}

时间复杂度分析：

平均情况：O(n log n)
最坏情况（已排序数组）：O(n²)

3. 二分查找（Binary Search）

二分查找是分治策略在搜索问题中的应用：

int binarySearch(vector<int>& nums, int target) {
    int left = 0, right = nums.size() - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        
        if (nums[mid] == target) 
            return mid;      // 找到目标
        else if (nums[mid] < target) 
            left = mid + 1; // 目标在右半区
        else 
            right = mid - 1; // 目标在左半区
    }
    
    return -1; // 未找到
}

时间复杂度：O(log n)

4. 汉诺塔问题（Tower of Hanoi）

void hanoi(int n, char from, char to, char aux) {
    if (n == 1) {
        cout << "Move disk 1 from " << from << " to " << to << endl;
        return;
    }
    
    // 将n-1个盘子从起始柱移动到辅助柱
    hanoi(n - 1, from, aux, to);
    
    // 移动最底下的盘子
    cout << "Move disk " << n << " from " << from << " to " << to << endl;
    
    // 将n-1个盘子从辅助柱移动到目标柱
    hanoi(n - 1, aux, to, from);
}

时间复杂度：O(2ⁿ)