2026-04-24：最大和最小 K 个元素的绝对差。用go语言，给定整数数组 nums 和整数 k，分别取出数组里最大的 k 个数并求它们的和；再取出数组里最小的 k 个数并求它们的和。最后计算这两个和之间的差值的绝对值，并返回该结果。

1 <= n == nums.length <= 100。

1 <= nums[i] <= 100。

1 <= k <= n。

输入： nums = [5,2,2,4], k = 2。

输出： 5。

解释：

k = 2 个最大的元素是 4 和 5。它们的总和是 4 + 5 = 9。

k = 2 个最小的元素是 2 和 2。它们的总和是 2 + 2 = 4。

绝对差值是 abs(9 - 4) = 5。

题目来自力扣3774。

代码执行过程

我们以输入 nums = [5, 2, 2, 4]，k = 2 为例，完整拆解执行步骤：

第一步：定义求和工具函数

程序先定义了一个 sum 函数，作用是接收一个整数切片，遍历里面所有数字并累加，返回最终的总和，专门用来计算数组片段的和。

第二步：执行核心计算函数 absDifference

这是实现题目要求的核心函数，执行步骤如下：

1. 对原数组进行升序排序
   传入的数组是 [5,2,2,4]，排序后从小到大排列为：[2, 2, 4, 5]。
2. 截取最小的 k 个元素并求和
   排序后的数组前 k 个元素就是最小的 k 个数，这里 k=2，截取片段为 [2, 2]；
   调用 sum 函数遍历累加，得到最小 k 个数的和：2+2=4。
3. 截取最大的 k 个元素并求和
   排序后的数组最后 k 个元素就是最大的 k 个数，这里 k=2，截取片段为 [4, 5]；
   调用 sum 函数遍历累加，得到最大 k 个数的和：4+5=9。
4. 计算两个和的差值
   用最大 k 数的和 减去 最小 k 数的和：9 - 4 = 5；
   因为题目要求绝对差值，而最大和一定大于等于最小和，所以差值本身就是最终结果。

第三步：主函数调用与输出

1. 在 main 函数中定义测试用的数组 nums 和整数 k；
2. 调用核心函数 absDifference 得到计算结果 5；
3. 将结果打印输出，控制台显示 5。

时间复杂度与空间复杂度分析

1. 总时间复杂度

时间复杂度由代码中最耗时的操作决定：

• 核心耗时操作：数组排序，Go 语言 slices.Sort 对整型切片排序的时间复杂度为 O(n log n)（n 是数组长度）；
• 求和操作：两次遍历长度为 k 的切片，总时间为 O(k)，远小于排序的耗时；
• 其他操作（截取切片、减法）都是常数时间 O(1)。

因此，总的时间复杂度为 O(n log n)。

2. 总额外空间复杂度

额外空间指除了输入数据外，程序运行时额外开辟的内存空间：

• slices.Sort 是原地排序，不会开辟新的数组空间；
• 切片截取操作只是创建新的切片引用，不复制底层数组数据；
• 仅使用了少量变量存储和、临时值，占用常数空间；

因此，总的额外空间复杂度为 O(1)（常数级空间）。

总结

1. 执行核心流程：排序数组 → 取前k小求和 → 取后k大求和 → 计算差值；
2. 总时间复杂度：O(n log n)（由排序操作决定）；
3. 总额外空间复杂度：O(1)（原地操作，无额外内存开销）。

Go完整代码如下：

package main

import (
	"fmt"
	"slices"
)

func sum(a []int) (s int) {
	for _, x := range a {
		s += x
	}
	return s
}

func absDifference(nums []int, k int) int {
	slices.Sort(nums)
	return sum(nums[len(nums)-k:]) - sum(nums[:k])
}

func main() {
	nums := []int{5, 2, 2, 4}
	k := 2
	result := absDifference(nums, k)
	fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

def sum_array(a):
    """计算列表元素的和"""
    return sum(a)

def abs_difference(nums, k):
    """计算最大k个元素之和与最小k个元素之和的差"""
    nums.sort()  # 原地排序
    # 最大k个元素之和 - 最小k个元素之和
    return sum(nums[-k:]) - sum(nums[:k])

def main():
    nums = [5, 2, 2, 4]
    k = 2
    result = abs_difference(nums, k)
    print(result)

if __name__ == "__main__":
    main()

C++完整代码如下：

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

int absDifference(std::vector<int>& nums, int k) {
    std::sort(nums.begin(), nums.end());

    // 计算前k个元素的和
    int sumMin = std::accumulate(nums.begin(), nums.begin() + k, 0);

    // 计算后k个元素的和
    int sumMax = std::accumulate(nums.end() - k, nums.end(), 0);

    return sumMax - sumMin;
}

int main() {
    std::vector<int> nums = {5, 2, 2, 4};
    int k = 2;
    int result = absDifference(nums, k);
    std::cout << result << std::endl;
    return 0;
}