2026-03-21：找出缺失的元素。用go语言，给定一个整数数组 nums，其中的元素彼此不重复。 原先 nums 本应包含某个连续整数区间内全部的整数，但现

2026-03-21：找出缺失的元素。用go语言，给定一个整数数组 nums，其中的元素彼此不重复。

原先 nums 本应包含某个连续整数区间内全部的整数，但现在可能会漏掉一些。

这个区间的端点（最小值、最大值）都仍然在 nums 里存在。

你的任务是：找出该区间内那些没有出现在 nums 中的整数。

将这些缺失的数按升序返回；如果区间内没有缺失项，则返回空列表。

2 <= nums.length <= 100。

1 <= nums[i] <= 100。

输入： nums = [5,1]。

输出： [2,3,4]。

解释：

最小整数为 1，最大整数为 5，因此完整的范围应为 [1,2,3,4,5]。缺失的整数为 2、3 和 4。

题目来自力扣3731。

一、程序整体执行流程

程序分为两个部分：main 主函数（负责输入和输出）、findMissingElements 核心函数（负责找缺失元素）。 执行顺序：main函数调用核心函数 → 核心函数分步处理 → 返回结果 → main函数打印结果。

---

二、分步骤详细执行过程

步骤1：main函数初始化输入

1. 定义整数数组 nums = [5, 1]
2. 调用核心函数 findMissingElements，把数组 [5,1] 传入函数
3. 等待函数返回结果，最后打印结果

---

步骤2：进入 findMissingElements 核心函数，初始化变量

函数一开始会创建3个关键变量，用于后续计算：

1. mn：存储数组的最小值，初始值设为整数最大值（保证任何数组元素都比它小）
2. mx：存储数组的最大值，初始值设为整数最小值（保证任何数组元素都比它大）
3. has：一个空的映射（字典），作用是快速判断某个数字是否存在于数组中
4. ans：空切片，用来存储最终找到的缺失元素

---

步骤3：遍历数组，更新最值 + 记录元素存在状态

开始逐个遍历数组 [5, 1] 里的每一个数字：

第一次遍历：数字 = 5

1. 比较当前最小值 mn 和 5：5 更小 → mn 更新为 5
2. 比较当前最大值 mx 和 5：5 更大 → mx 更新为 5
3. 把 5 存入映射 has，标记为：数字5存在

第二次遍历：数字 = 1

1. 比较当前最小值 mn=5 和 1：1 更小 → mn 更新为 1
2. 比较当前最大值 mx=5 和 1：5 更大 → mx 保持 5 不变
3. 把 1 存入映射 has，标记为：数字1存在

✅ 遍历结束后结果：

• 数组最小值 mn = 1
• 数组最大值 mx = 5
• 映射 has 记录：1、5 这两个数字存在

---

步骤4：遍历区间 [最小值+1，最大值-1]，查找缺失元素

已知完整区间是 1 ~ 5，我们只需要检查 1和5之间的数字（2、3、4），判断是否在数组中：

遍历规则：从 mn+1 = 2 开始，到 mx-1 = 4 结束，逐个检查：

1. 数字 2：映射中没有记录 → 判定为缺失，加入结果列表
2. 数字 3：映射中没有记录 → 判定为缺失，加入结果列表
3. 数字 4：映射中没有记录 → 判定为缺失，加入结果列表

✅ 此步骤结束后： 结果列表 ans = [2, 3, 4]

---

步骤5：函数返回结果，main函数打印输出

核心函数将结果 [2,3,4] 返回给 main 函数，程序打印输出： [2 3 4]，与题目要求完全一致。

---

三、时间复杂度分析

时间复杂度：O(n)

• n 代表输入数组的长度
• 程序只做了两次线性遍历：
  1. 第一次遍历数组：O(n)
  2. 第二次遍历连续区间：长度最大为 100（题目限制），是常数级别
• 常数不影响复杂度，总时间复杂度为 O(n)

---

四、额外空间复杂度分析

额外空间复杂度：O(n)

• 额外空间：指除了输入和输出之外，程序额外开辟的内存
• 主要占用空间的是映射 has：最多存储 n 个元素（数组所有元素）
• 其他变量（最值、结果列表）都是常数或输出空间，不计入额外空间
• 总额外空间复杂度为 O(n)

---

总结

1. 执行过程：初始化→遍历求最值+记录元素→遍历区间找缺失→返回结果
2. 时间复杂度：O(n)（线性时间）
3. 额外空间复杂度：O(n)（线性空间）

Go完整代码如下：

package main

import (
	"fmt"
	"math"
)

func findMissingElements(nums []int) (ans []int) {
	mn, mx := math.MaxInt, math.MinInt
	has := map[int]bool{}
	for _, x := range nums {
		mn = min(mn, x)
		mx = max(mx, x)
		has[x] = true
	}

	for i := mn + 1; i < mx; i++ {
		if !has[i] {
			ans = append(ans, i)
		}
	}
	return
}

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

Python完整代码如下：

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

import math
from typing import List

def find_missing_elements(nums: List[int]) -> List[int]:
    mn, mx = math.inf, -math.inf
    has = set()
    for x in nums:
        mn = min(mn, x)
        mx = max(mx, x)
        has.add(x)

    ans = []
    for i in range(mn + 1, mx):
        if i not in has:
            ans.append(i)
    return ans

def main():
    nums = [5, 1]
    result = find_missing_elements(nums)
    print(result)

if __name__ == "__main__":
    main()

C++完整代码如下：

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

std::vector<int> findMissingElements(std::vector<int>& nums) {
    int mn = INT_MAX;
    int mx = INT_MIN;
    std::unordered_set<int> has;

    for (int x : nums) {
        mn = std::min(mn, x);
        mx = std::max(mx, x);
        has.insert(x);
    }

    std::vector<int> ans;
    for (int i = mn + 1; i < mx; i++) {
        if (has.find(i) == has.end()) {
            ans.push_back(i);
        }
    }
    return ans;
}

int main() {
    std::vector<int> nums = {5, 1};
    std::vector<int> result = findMissingElements(nums);

    for (int i = 0; i < result.size(); i++) {
        std::cout << result[i];
        if (i < result.size() - 1) {
            std::cout << " ";
        }
    }
    std::cout << std::endl;

    return 0;
}