Easy

题目描述

给你一个整数数组 nums。

nums 的交替和是通过将偶数索引处的元素相加，奇数索引处的元素相减得到的值。也就是说，nums[0] - nums[1] + nums[2] - nums[3]...

返回表示 nums 交替和的整数。

示例 1：

输入：nums = [1,3,5,7]
输出：-4
解释：
偶数索引处的元素是 nums[0] = 1 和 nums[2] = 5，因为 0 和 2 是偶数。
奇数索引处的元素是 nums[1] = 3 和 nums[3] = 7，因为 1 和 3 是奇数。
交替和为 nums[0] - nums[1] + nums[2] - nums[3] = 1 - 3 + 5 - 7 = -4。

示例 2：

输入：nums = [100]
输出：100
解释：
偶数索引处唯一的元素是 nums[0] = 100，因为 0 是偶数。
没有奇数索引处的元素。
交替和为 nums[0] = 100。

提示：

  • 1 <= nums.length <= 100
  • 1 <= nums[i] <= 100

解题思路

这道题目要求计算数组的交替和，即偶数索引的元素为正号，奇数索引的元素为负号。

解法分析：

  1. 直接遍历法（推荐）：遍历数组，根据索引的奇偶性决定加减操作
  2. 符号控制法：使用一个符号变量，每次遍历后翻转符号

解题思路：

最直观的方法是遍历整个数组，对于每个位置判断索引是否为偶数。如果是偶数索引，将该元素加到结果中；如果是奇数索引，从结果中减去该元素。

另一种更简洁的思路是使用符号控制。初始化符号为 1，每次将当前元素乘以符号后加到结果中，然后将符号取反。这样可以避免每次都判断索引的奇偶性。

由于数组长度最大为 100，元素值最大为 100，所以不用担心整数溢出问题。时间复杂度为 O(n)，空间复杂度为 O(1)，效率很高。

代码实现

class Solution {
public:
    int alternatingSum(vector<int>& nums) {
        int sum = 0;
        int sign = 1;
        
        for (int num : nums) {
            sum += sign * num;
            sign = -sign;
        }
        
        return sum;
    }
};

class Solution:
    def alternatingSum(self, nums: List[int]) -> int:
        sum_val = 0
        sign = 1
        
        for num in nums:
            sum_val += sign * num
            sign = -sign
        
        return sum_val

public class Solution {
    public int AlternatingSum(int[] nums) {
        int sum = 0;
        int sign = 1;
        
        foreach (int num in nums) {
            sum += sign * num;
            sign = -sign;
        }
        
        return sum;
    }
}

/**
 * @param {number[]} nums
 * @return {number}
 */
var alternatingSum = function(nums) {
    let sum = 0;
    let sign = 1;
    
    for (let num of nums) {
        sum += sign * num;
        sign = -sign;
    }
    
    return sum;
};
在 LeetCode 上运行： 力扣中文版 LeetCode 国际版

复杂度分析

复杂度大O表示法说明
时间复杂度O(n)需要遍历数组一次，n为数组长度
空间复杂度O(1)只使用了常数个额外变量

相关题目