JS实现 LeetCode 数组类算法（六）

更多算法实现见：https://github.com/Erindcl/Daily-algorithm

724. 寻找数组的中心索引

• 给定一个整数类型的数组 nums，请编写一个能够返回数组“中心索引”的方法。
• 我们是这样定义数组中心索引的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。
• 如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。

分析：遍历数组，分别计算i左侧元素和与右侧元素和的大小，当两侧元素和相等，则i即为中心索引。代码如下：

var pivotIndex = function(nums) {
    let len = nums.length;
    for (let i = 0; i < len; i++) {
        let sumL = 0, sumR = 0;
        for(let j = 0; j < i; j++) {
            sumL += nums[j];
        }
        for(let k = i + 1; k < len; k++) {
            sumR += nums[k];
        }
        if (sumR == sumL) {
            return i;
        }
    }
    return -1;
};

其他实现：

var pivotIndex = function(nums) {
    let len = nums.length, currS = 0;
    let sum = nums.reduce((a,b) => a+b, 0); // 利用reduce累加器计算数组的和
    for (let i = 0; i < len; i++) {
        if (sum == currS * 2 + nums[i]) {
            return i;
        }
        currS += nums[i];
    }
    return -1;
};

746. 使用最小花费爬楼梯

• 数组的每个索引做为一个阶梯，第 i个阶梯对应着一个非负数的体力花费值 cost[i](索引从0开始)。
• 每当你爬上一个阶梯你都要花费对应的体力花费值，然后你可以选择继续爬一个阶梯或者爬两个阶梯。
• 您需要找到达到楼层顶部的最低花费。在开始时，你可以选择从索引为 0 或 1 的元素作为初始阶梯。

分析：动态规划：找到关键的状态方程dp[i] = min(dp[i-1], dp[i-2])+cost[i],使得dp数组每一个位置都存放当前的最小答案。代码如下：

var minCostClimbingStairs = function(cost) {
    let len = cost.length;
    if (len <= 2) {
        return 0;
    }
    let dp = [cost[0],cost[1]]; 
    for (let i = 2; i < len; i++) {
        let curr = Math.min(dp[i-1],dp[i-2]) + cost[i];
        dp.push(curr);
    }
    return Math.min(dp[len - 1],dp[len - 2]);
};

其他实现：

var minCostClimbingStairs = function(cost) {
    for(let i = 2; i < cost.length; i++) {
        cost[i] = cost[i] + Math.min(cost[i - 1], cost[i - 2]);
    }
    return Math.min(cost[cost.length - 1], cost[cost.length - 2]);
}

747. 至少是其他数字两倍的最大数

• 在一个给定的数组nums中，总是存在一个最大元素 。
• 查找数组中的最大元素是否至少是数组中每个其他数字的两倍。
• 如果是，则返回最大元素的索引，否则返回-1。

代码如下：

var dominantIndex = function(nums) {
    let max = Math.max(...nums);
    let maxIndex = nums.indexOf(max);
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] != max && max / 2 < nums[i]) {
            return -1;
        }
    }
    return maxIndex;
};

766. 托普利茨矩阵

• 如果一个矩阵的每一方向由左上到右下的对角线上具有相同元素，那么这个矩阵是托普利茨矩阵。
• 给定一个 M x N 的矩阵，当且仅当它是托普利茨矩阵时返回 True。

代码如下：

var isToeplitzMatrix = function(matrix) {
    let lenN = matrix.length;
    let lenM = matrix[0].length;
    for (let i = 0; i < lenN - 1; i++) {
        for (let j = 0; j < lenM - 1; j++) {
            if (matrix[i][j] != matrix[i+1][j+1]) {
                return false;
            }
        }
    }
    return true;
};

830. 较大分组的位置

• 在一个由小写字母构成的字符串 S 中，包含由一些连续的相同字符所构成的分组。
• 例如，在字符串 S = "abbxxxxzyy" 中，就含有 "a", "bb", "xxxx", "z" 和 "yy" 这样的一些分组。
• 我们称所有包含大于或等于三个连续字符的分组为较大分组。找到每一个较大分组的起始和终止位置。
• 最终结果按照字典顺序输出。

代码如下：

var largeGroupPositions = function(S) {
    let map = new Map(), currIndex = 0, currS = S[0];
    let result = [], sArr = S.split('');
    for (let i = 1; i < S.length; i++) {
        if (S[i] == S[i-1]) {
            currS += S[i];
        } else {
            if (currS.length >= 3) {
                let currArr = [currIndex, parseInt(currIndex) + parseInt(currS.length) - 1];
                result.push(currArr);
            }
            currIndex = i;
            currS = S[i];
        }
    }
    if (currS.length >= 3) {
        let currArr = [currIndex, parseInt(currIndex) + parseInt(currS.length) - 1];
        result.push(currArr);
    }
    return result;
};

其他实现：

var largeGroupPositions = function(S) {
    let outPut=[]
    let reg=/([a-z])\1\1+/g
    let out=reg.exec(S)
    while(out)
        {
            outPut.push([out.index,out.index+out[0].length-1])
            out=reg.exec(S)
        }
    return outPut
};