算法：分治法-力扣题最大子数组和

概念

分治法是一种算法思想，其核心思想是将一个大问题分割成若干个小问题来解决。通过对小问题的分别计算，最终得到大问题的解。

应用

分治法的常见应用包括排序、查找、计算几何、图形处理等。它的优点在于可以大大降低计算量，提高程序运行效率。同时，分治法的模型较为简单，易于理解。

步骤

分治法的具体实现通常分为三个步骤：

1.分割：将原问题划分为若干个规模较小的子问题。

2.解决：递归地解决划分出来的子问题。如果子问题足够小，则直接用简单的方法求解。

3.合并：将已解决的子问题的解合并成原问题的解。

实现过程-快速排序为例

下面以快速排序为例详细介绍分治法的实现过程：

快速排序：

快速排序是一种常用的排序算法，其基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均小于另一部分的关键字，然后再分别对这两部分记录递归地进行排序，以达到整个序列有序的目的。

具体实现步骤：

1.选取基准值：从数列中挑出一个元素，作为基准值。

2.分割：将数列中所有小于等于基准值的元素放到基准值前面，所有大于基准值的元素放到基准值后面（相当于将问题分割为两部分）。

3.解决：递归地对分割后的两部分进行快速排序。

4.合并：不需要进行合并操作，因为分割后两部分是相互独立的。

代码实现：

void quickSort(int arr[], int left, int right) {
    int i = left, j = right;
    int tmp;
    int pivot = arr[(left + right) / 2];

    /* partition */
    while (i <= j) {
        while (arr[i] < pivot)
            i++;
        while (arr[j] > pivot)
            j--;
        if (i <= j) {
            tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            i++;
            j--;
        }
    };

    /* recursion */
    if (left < j)
        quickSort(arr, left, j);
    if (i < right)
        quickSort(arr, i, right);
}

分治法是一种非常实用的算法思想，在处理大数据量、复杂问题时，分治法能够提供有效的解决方案。同时，分治法也有其局限性，例如需要额外的空间来存储数据和递归调用开销。因此，在实际应用过程中，需要根据具体情况选择分治法或其他算法思想来解决问题。

力扣-2586统计范围内的元音字符

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
示例 2：

输入：nums = [1]
输出：1
示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

提示：
1 <= nums.length <= 105
-104 <= nums[i] <= 104

题解

连续子序列的最大和主要由这三部分子区间里元素的最大和得到：

第 1 部分：子区间 [left, mid]；
第 2 部分：子区间 [mid + 1, right]；
第 3 部分：包含子区间 [mid , mid + 1] 的子区间，即 nums[mid] 与 nums[mid + 1] 一定会被选取。
对这三个部分求最大值即可。

说明：考虑第 3 部分跨越两个区间的连续子数组的时候，由于 nums[mid] 与 nums[mid + 1] 一定会被选取，可以从中间向两边扩散，扩散到底 选出最大值

public class Solution { // 定义一个名为 Solution 的公开类  
  
    public int maxSubArray(int[] nums) { // 定义一个公开方法 maxSubArray，输入参数为一个整数数组 nums  
        int len = nums.length; // 获取输入数组的长度  
        if (len == 0) { // 如果数组长度为0  
            return 0; // 返回0，因为不存在子数组  
        }  
        return maxSubArraySum(nums, 0, len - 1); // 否则，调用 maxSubArraySum 方法求解  
    }  
  
    // 定义一个私有方法 maxCrossingSum，输入参数为一个整数数组 nums、左边界 left、中间点 mid 和右边界 right  
    private int maxCrossingSum(int[] nums, int left, int mid, int right) {  
        // 一定会包含 nums[mid] 这个元素  
        int sum = 0; // 初始化 sum 为0，用于保存交叉子数组的和  
        int leftSum = Integer.MIN_VALUE; // 初始化 leftSum 为最小整数值，用于保存左半部分最大子数组的和  
        // 左半边包含 nums[mid] 元素，最多可以到什么地方  
        // 走到最边界，看看最值是什么  
        // 计算以 mid 结尾的最大的子数组的和  
        for (int i = mid; i >= left; i--) {  
            sum += nums[i]; // 将当前元素加入 sum  
            if (sum > leftSum) {  
                leftSum = sum; // 如果 sum 大于 leftSum，则更新 leftSum  
            }  
        }  
        sum = 0; // 重置 sum 为0，用于保存右半部分交叉子数组的和  
        int rightSum = Integer.MIN_VALUE; // 初始化 rightSum 为最小整数值，用于保存右半部分最大子数组的和  
        // 右半边不包含 nums[mid] 元素，最多可以到什么地方  
        // 计算以 mid+1 开始的最大的子数组的和  
        for (int i = mid + 1; i <= right; i++) {  
            sum += nums[i]; // 将当前元素加入 sum  
            if (sum > rightSum) {  
                rightSum = sum; // 如果 sum 大于 rightSum，则更新 rightSum  
            }  
        }  
        return leftSum + rightSum; // 返回左右两个最大子数组和之和  
    }  
  
    // 定义一个私有方法 maxSubArraySum，输入参数为一个整数数组 nums、左边界 left 和右边界 right  
    private int maxSubArraySum(int[] nums, int left, int right) {  
        if (left == right) { // 如果左边界和右边界相等，说明只有一个元素  
            return nums[left]; // 直接返回这个元素的值作为最大子数组和  
        }  
        int mid = left + (right - left) / 2; // 计算中间点 mid，用于进行分治处理  
        return max3(maxSubArraySum(nums, left, mid), // 分治处理：对左半部分递归求解最大子数组和  
                maxSubArraySum(nums, mid + 1, right), // 分治处理：对右半部分递归求解最大子数组和  
                maxCrossingSum(nums, left, mid, right)); // 分治处理：求解穿过 mid 的最大交叉子数组和  
    }  
  
    // 定义一个私有方法 max3，输入参数为三个整数 num1、num2 和 num3  
    private int max3(int num1, int num2, int num3) { // 求三个数中的最大值  
        return Math.max(num1, Math.max(num2, num3)); // 使用 Math.max 方法求得最大值并返回  
    }  
}

时间复杂度：O(Nlog⁡N)，每一层需要遍历一遍数组（或者数组的一半、四分之一）；