2026-03-31：三元素表达式的最大值。用go语言，从数组 nums 中任选三个下标互不相同的元素，设这三个元素分别为 a、b、c（对应的下标不能重复）。

2026-03-31：三元素表达式的最大值。用go语言，从数组 nums 中任选三个下标互不相同的元素，设这三个元素分别为 a、b、c（对应的下标不能重复）。

计算表达式 a + b - c，希望让它的结果尽可能大。

最终返回所有可能选择中，该表达式取得的最大值。

3 <= nums.length <= 100。

-100 <= nums[i] <= 100。

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

输出： 8。

解释：

可以选择 a = 4，b = 5，c = 1。表达式的值为 4 + 5 - 1 = 8，这是可能的最大值。

题目来自力扣3745。

一、核心解题思路

要让表达式 a + b - c 的结果最大，数学逻辑是：

• 让 a + b 的值尽可能大（选数组中最大的两个数）
• 让 c 的值尽可能小（选数组中最小的一个数） 同时满足：a、b、c 是数组中下标互不相同的三个元素。

二、代码执行详细步骤（以输入 nums = [1,4,2,5] 为例）

步骤1：初始化三个关键变量

• mx：存储数组中的最大值，初始值设为整数最小值（保证任何数组元素都比它大）
• mx2：存储数组中的第二大值，初始值同样设为整数最小值
• mn：存储数组中的最小值，初始值设为整数最大值（保证任何数组元素都比它小）

步骤2：遍历数组中的每一个元素，逐个更新变量

数组元素依次为：1 → 4 → 2 → 5，逐个处理：

1. 处理第一个元素 1

   • 1 大于当前最大值 mx（初始最小值），所以： 第二大值 mx2 更新为原来的最大值（初始最小值） 最大值 mx 更新为 1
   • 1 小于当前最小值 mn（初始最大值），最小值 mn 更新为 1
   • 此时变量：mx=1，mx2=最小数，mn=1

2. 处理第二个元素 4

   • 4 大于当前最大值 mx（1），所以： 第二大值 mx2 更新为原来的最大值 1 最大值 mx 更新为 4
   • 4 大于当前最小值 mn（1），最小值保持 1 不变
   • 此时变量：mx=4，mx2=1，mn=1

3. 处理第三个元素 2

   • 2 不大于当前最大值 mx（4），但大于第二大值 mx2（1），所以： 第二大值 mx2 更新为 2 最大值 mx 保持 4 不变
   • 2 大于当前最小值 mn（1），最小值保持 1 不变
   • 此时变量：mx=4，mx2=2，mn=1

4. 处理第四个元素 5

   • 5 大于当前最大值 mx（4），所以： 第二大值 mx2 更新为原来的最大值 4 最大值 mx 更新为 5
   • 5 大于当前最小值 mn（1），最小值保持 1 不变
   • 此时变量：mx=5，mx2=4，mn=1

步骤3：计算最终结果

用 最大值 + 第二大值 - 最小值 计算： 5 + 4 - 1 = 8，和题目要求的输出结果一致。

步骤4：返回结果并输出

将计算得到的 8 作为最终结果返回，主函数打印输出。

三、时间复杂度分析

• 代码中只执行了一次数组遍历，遍历的次数等于数组的长度 n。
• 遍历过程中的每一步操作（比较、赋值、计算）都是常数时间 O(1)。
• 总时间复杂度：O(n)（n 为数组长度）。

四、额外空间复杂度分析

• 代码中没有创建与数组长度相关的新数据结构（如新数组、切片等）。
• 只使用了 3 个固定的变量（mx、mx2、mn），占用的空间是常数，不随数组长度变化。
• 总额外空间复杂度：O(1)。

---

总结

1. 求解核心：选最大两数相加，减去最小数，保证三个数下标不同；
2. 执行过程：初始化变量→遍历数组更新最大、第二大、最小值→计算表达式→输出结果；
3. 时间复杂度 O(n)，仅需一次遍历；
4. 额外空间复杂度 O(1)，仅使用固定数量的变量。

Go完整代码如下：

package main

import (
	"fmt"
	"math"
)

func maximizeExpressionOfThree(nums []int) int {
	mx, mx2, mn := math.MinInt, math.MinInt, math.MaxInt
	for _, x := range nums {
		if x > mx {
			mx2 = mx
			mx = x
		} else if x > mx2 {
			mx2 = x
		}
		mn = min(mn, x)
	}
	return mx + mx2 - mn
}

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

Python完整代码如下：

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

import math
from typing import List

def maximize_expression_of_three(nums: List[int]) -> int:
    mx = -math.inf
    mx2 = -math.inf
    mn = math.inf
    
    for x in nums:
        if x > mx:
            mx2 = mx
            mx = x
        elif x > mx2:
            mx2 = x
        mn = min(mn, x)
    
    return mx + mx2 - mn

def main():
    nums = [1, 4, 2, 5]
    result = maximize_expression_of_three(nums)
    print(result)

if __name__ == "__main__":
    main()

C++完整代码如下：

#include <iostream>
#include <vector>
#include <climits>
#include <algorithm>

int maximizeExpressionOfThree(const std::vector<int>& nums) {
    int mx = INT_MIN;
    int mx2 = INT_MIN;
    int mn = INT_MAX;

    for (int x : nums) {
        if (x > mx) {
            mx2 = mx;
            mx = x;
        } else if (x > mx2) {
            mx2 = x;
        }
        mn = std::min(mn, x);
    }

    return mx + mx2 - mn;
}

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