每天写两道(四)最大子数组和、手撕快排

53.最大子数组和

. - 力扣（LeetCode）

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

子数组

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

示例 1：

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

思路：动态规划，可以理解为抱桃子找西瓜的操作，每次移动都和前一组子数组之和进行比较，如果当前的一个值就大于之前的值加现在的值了，那就直接抛弃前面的子数组，从当前组开始计数 

实现：

var maxSubArray = function(nums) {
    // 动态规划
    let pre = 0
    // 如果maxSum初始值设为0，那么可能会出现第一轮的maxSum=0的情况，
    // 而实际maxSum应该等于nums数组的子数组和
    let maxSum = nums[0] 
    // 如果当前数比之前加起来的都大，就直接放弃前面的 从这个位置开始计数
    nums.forEach(x=>{
        pre = Math.max(pre+x,x)
        maxSum = Math.max(pre,maxSum)
    })
    return maxSum
};

512.排序数组

给你一个整数数组 nums，请你将该数组升序排列

思路：快速排序 选择一个基准，比基准大的放右边，比基准小的放左边

实现：

var sortArray = function (nums) {
    if (nums.length < 2) return nums;
    return quickSort(nums, 0, nums.length - 1);
};

function quickSort(nums, left, right) {
    if (left < right) {
        // 分出小份 继续快排
        let mid = partition(nums, left, right)
        quickSort(nums, left, mid - 1)
        quickSort(nums, mid + 1, right)
    }
    return nums
}

function partition(nums, left, right) {
    if (left >= right) return
    // 以最左边值为基准，小于基准的左移，大于的右移
    let base = nums[left]
    while (left < right) {
        // 先从后往前 如果right大于基准就跳过
        while (left < right && nums[right] >= base) right--
        nums[left] = nums[right]
        // 再从前往后 如果left值小于基准就跳过
        while (left < right && nums[left] < base) left++
        nums[right] = nums[left]
    }
    // 将基准填补到中间的空缺 也就是left的位置
    nums[left] = base
    return left // 返回中间值
}

超时了。。。不是。。这？？ 迷惑 

明天再来研究 

5.31补：

昨晚听说是因为基准设置为最左边的原因，遇上极端情况时间复杂度就是O(n2)了，所以试了试随机基准：

var sortArray = function (nums) {
    if (nums.length < 2) return nums;
    return quickSort(nums, 0, nums.length - 1);
};

function quickSort(nums, left, right) {
    if (left < right) {
        // 分出小份 继续快排
        let mid = partition(nums, left, right)
        quickSort(nums, left, mid - 1)
        quickSort(nums, mid + 1, right)
    }
    return nums
}

function partition(nums, left, right) {
    if (left >= right) return
    // 采用随机基准数
    let random = left + Math.floor(Math.random() * (right - left + 1))
    let temp = nums[left]
    nums[left] = nums[random]
    nums[random] = temp

    let i = left, j = right
    while (i < j) {
        while (i < j && nums[j] >= nums[left]) j--
        while (i < j && nums[i] < nums[left]) i++
        // 交换
        let tmp = nums[i]
        nums[i] = nums[j]
        nums[j] = tmp
    }
    let tmp = nums[left]
    nums[left] = nums[i]
    nums[i] = tmp

    return i // 返回中间值
}

呃啊？我们的代码不一样吗 请问？？ 

后面又看了一个佬的随机基准+三指针的快排 牛波

var sortArray = function (nums) {
    // 快速排序
    if (nums.length < 2) return nums;
    return quickSort(nums, 0, nums.length - 1);
};

function quickSort(nums, left, right) {
    if (left >= right) return;
    let [leftIndex, rightIndex] = partition(nums, left, right)

    quickSort(nums, left, leftIndex - 1)
    quickSort(nums, rightIndex, right)
    return nums;
}

var partition = function (nums, leftIndex, rightIndex) {
    // 随机基准+三指针
    const curr = nums[Math.floor(Math.random() * (rightIndex - leftIndex + 1)) + leftIndex];
    let index = leftIndex;
    while (index <= rightIndex) {
        if (nums[index] < curr) {
            [nums[leftIndex], nums[index]] = [nums[index], nums[leftIndex]];
            leftIndex++;
            index++;
            continue;
        }
        if (nums[index] === curr) {                                              
            index++;
            continue;
        }
        if (nums[index] > curr) {
            [nums[rightIndex], nums[index]] = [nums[index], nums[rightIndex]];
            rightIndex--;
        }
    }
    return [leftIndex, rightIndex];
};

 过了过了 嘎嘎爽

就是还有点记不住，画图是理解到了那个巧妙的感觉，比双指针要更快