<think>根据用户需求，我们需要实现
一个Black Box数据库模拟器，处理两种命令：ADD和GET。ADD命令添加
一个元素，GET命令返回当前第k小的
元素（k是GET命令调用时的序号，即第几次GET）。
设计思路：
我们使用两个堆：
-
一个最大堆（max_heap）存储当前最小的k个
元素（堆顶是这k个
元素中的最大值，即第k小
元素）
-
一个最小堆（min_heap）存储剩余的
元素（堆顶是剩余
元素中的最小值）
操作流程：
1. 初始化时，最大堆为
空，最小堆为
空。
2. 对于
每个ADD(x)操作：
- 如果当前最大堆的大小小于k（即当前GET命令的序号，注意：k会随着GET命令的调用而递增），那么我们将x加入最小堆，然后调整：将最小堆的堆顶
元素移到最大堆（这样最大堆的大小就增加了1，符合新的k）。
- 否则，如果x小于最大堆的堆顶（说明x属于前k小），那么将x加入最大堆，然后调整：将最大堆的堆顶移到最小堆（因为此时最大堆的大小超过了k）。否则，将x加入最小堆。
- 但是注意：在加入x后，我们可能需要调整两个堆，使得最大堆的大小恰好为当前要求的k（即已经调用的GET命令次数）。
然而，注意题目中GET命令的调用顺序：每次GET命令会返回当前第k小的
元素，其中k是当前GET命令的序号（从1开始）。在ADD命令中，我们需要知道当前的k（即已经调用过多少次GET命令+1？）。实际上，在Black Box问题中，ADD和GET命令是交替进行的，并且GET命令的序号是递增的。
具体实现：
我们用
一个变量k_index来记录当前已经进行了多少次GET命令（即下
一次GET命令的k值应该是k_index+1）。但是注意，在ADD命令中，我们并不知道下
一次GET命令何时到来，所以我们需要在每次GET命令时调整堆，使得最大堆的大小恰好为当前的k_index（即已经完成的GET命令次数，也就是当前需要返回第k_index小的
元素？）。
然而，实际上，Black Box问题的经典描述是：有一系列ADD命令和GET命令，GET命令按顺序出现（第1个GET命令要求第1小，第2个GET命令要求第2小，...）。在ADD命令的过程中，我们并不知道后面会有多少次ADD才到下
一个GET，所以我们需要在每次ADD后维护两个堆，使得最大堆的大小等于当前已经出现的GET命令次数（即k_index）。但是，在ADD命令中，我们并不调整到下
一个GET命令的k（因为下
一个GET命令的k是k_index+1），而是维持当前已经出现的GET命令次数对应的k。
因此，我们这样设计：
- 初始化：k_index = 0（表示还没有GET命令）
- 对于
每个ADD(x)：
将x加入最小堆。
然后，如果当前有未完成的GET命令（即k_index < 当前应该满足的GET序号？）实际上，我们并不需要立即调整。而是等到GET命令时再调整。
但是经典做法是：在每次GET命令之前，我们需要确保最大堆的大小等于当前GET命令的序号（即第k_index+1个GET命令，要求第k_index+1小的
元素）。因此，在GET命令时，我们需要将最小堆中的一些
元素移到最大堆，直到最大堆的大小等于k_index+1。
然而，为了在ADD命令中维护堆结构，我们可以在每次ADD后检查：如果当前最大堆的大小小于（k_index+1）且最小堆
非空，那么我们需要将最小堆的堆顶移到最大堆。这样，在GET命令时，最大堆的堆顶就是当前第k_index+1小的
元素。
具体步骤：
我们维护
一个整数k_index，表示当前已经执行了多少次GET命令（初始为0）。
ADD(x)
:
1. 如果当前最大堆的大小小于k_index+1（即下
一个GET命令要求的k值），那么我们可以将x加入最大堆（然后调整最大堆），然后将最大堆的堆顶移到最小堆（因为最大堆中只能保留k_index+1个
元素，但现在我们还没有达到这个数量，所以先加入再调整？）这并不正确。
另一种做法（经典对顶堆）：
1. 将x加入最大堆。
2. 将最大堆的堆顶弹出并加入最小堆（这样最大堆的大小不变，但是堆顶更新了，实际上这个操作是为了让最大堆中保留的是当前最小的k个
元素，但k是多少？）
3. 但是，如果当前最大堆的大小小于k_index，那么我们需要从最小堆中取回
一个元素到最大堆。
这并不直接。
更常见的做法（参考LeetCode 295. 数据流的中位数，但这里是第k小）：
我们维护两个堆，最大堆（保存当前最小的k个
元素，堆顶是这k个
元素中的最大值），最小堆（保存其他
元素）。
每次ADD(x)
:
如果最大堆的大小小于当前要求的k（即k_index+1，因为下
一个GET命令的k将是k_index+1），那么我们需要确保在GET命令时最大堆有k_index+1个
元素？实际上，我们并不提前知道下
一个GET命令何时到来，所以我们在ADD时并不调整到k_index+1，而是维持当前状态，等到GET命令时再调整。
但是题目要求是：GET命令返回当前第k小的
元素（k是GET命令的序号，从1开始），并且GET命令是按照序号递增的顺序出现的。
因此，我们可以这样：
- 初始化：k_index=0
- 对于
每个命令：
如果是ADD(x)：
将x加入最小堆。
如果是GET：
k_index++ // 表示现在要处理第k_index个GET命令
我们需要将最小堆中的一些
元素移到最大堆，直到最大堆的大小等于k_index（这样最大堆的堆顶就是第k_index小的
元素）
具体：当最大堆的大小小于k_index时，将最小堆的堆顶弹出并加入最大堆。
然后，输出最大堆的堆顶。
但是，这样在ADD时只加入最小堆，而在GET时从最小堆中取
元素到最大堆。这样可能导致最小堆中积累很多
元素，而最大堆只在GET时增加
元素。
然而，这样有
一个问题：如果当前最小堆为
空，那么无法移动
元素到最大堆。所以ADD(x)时，我们也可以考虑直接加入最大堆？但这样会破坏堆的性质。
经典做法（参考《
算法竞赛
入门经典》中的Black Box问题）：
使用
一个最大堆和
一个最小堆，最大堆保存当前最小的i个
元素（i为当前GET命令的次数），最小堆保存其他
元素。
当ADD(x)时：
如果最小堆为
空，则把x插入最小堆。
否则，比较x和最小堆的堆顶：
如果x小于最小堆堆顶，则将x插入最大堆（这样最大堆的大小可能超过i，后面调整）
否则，将x插入最小堆。
然后，如果最大堆的大小大于i（即当前已经完成的GET命令次数），那么将最大堆的堆顶移到最小堆。
如果最大堆的大小小于i，那么将最小堆的堆顶移到最大堆。
当GET时：
首先，i++（表示这是第i个GET命令）
然后，调整堆：如果最大堆的大小小于i，那么将最小堆的堆顶移到最大堆，直到最大堆的大小等于i。
此时，最大堆的堆顶就是第i小的
元素（即当前第i个GET命令的结果）。
但是，这个调整在ADD和GET中都有，且GET命令时也需要调整（因为i增加了）。
我们按照这个思路实现：
定义：
int i = 0; // 已经完成的GET命令次数
priority_queue<int> max_heap; // 最大堆，存储当前最小的i个
元素（堆顶是这i个
元素中的最大值，即第i小）
priority_queue<int, vector<int>, greater<int>> min_heap; // 最小堆，存储其他
元素
ADD(x)
:
if (min_heap.empty() || x < min_heap.top()) {
max_heap.push(x);
} else {
min_heap.push(x);
}
// 调整：如果max_heap的大小大于i（当前GET命令次数），则需要将max_heap的堆顶移到min_heap
while (max_heap.size() > i) {
int top = max_heap.top();
max_heap.pop();
min_heap.push(top);
}
// 调整：如果max_heap的大小小于i，则需要将min_heap的堆顶移到max_heap
while (max_heap.size() < i && !min_heap.empty()) {
int top = min_heap.top();
min_heap.pop();
max_heap.push(top);
}
GET()
:
i++; // 现在要查询第i小的
元素
// 调整：如果max_heap的大小小于i，那么需要从min_heap中移动
元素到max_heap
while (max_heap.size() < i && !min_heap.empty()) {
int top = min_heap.top();
min_heap.pop();
max_heap.push(top);
}
// 调整：如果max_heap的大小大于i，那么需要从max_heap中移动
元素到min_heap（这种情况可能不会发生，因为ADD时已经调整了，但i增加了，所以这里只需要调整小于的情况）
// 但是，由于i增加了，我们只需要确保max_heap的大小等于i，所以只需要从min_heap中补充到max_heap直到max_heap的大小等于i。
// 不过，在ADD时，我们调整了max_heap的大小等于i（但i还没有增加），所以现在i增加了，我们只需要补充到i。
// 因此，我们只需要上面的循环即可。
// 此时，max_heap的堆顶就是第i小的
元素
int result = max_heap.top();
// 注意：在GET命令后，我们不需要将堆顶弹出，因为后续ADD命令还需要这个堆顶。
// 但是，我们调整的步骤已经保证了堆的大小恰好为i（当前GET命令的次数），并且堆顶就是第i小
元素。
return result;
但是，注意在ADD命令中，我们有
一个调整：当max_heap的大小大于i时，我们会将堆顶移到min_heap。这样，在GET命令之前，max_heap的大小就是i（即上
一次GET命令完成后的i）。当GET命令时，i增加1，然后我们从min_heap中移动
元素到max_heap，直到max_heap的大小等于i。
这个实现符合要求。
但是，有
一个边界：当i=0时（即还没有GET命令），我们执行ADD(x)：
首先，min_heap为
空，所以x被加入max_heap。
然后，调整：max_heap的大小为1，大于i（0），所以将x移到min_heap。这样max_heap为
空，min_heap有
一个元素x。
然后，当第
一个GET命令时，i变成1，然后从min_heap中取出x放入max_heap，输出x。
这样是正确的。
但是，我们也可以优化：在ADD命令中，当i=0时，我们并不需要将x从max_heap移到min_heap，因为调整条件（max_heap.size()>i）满足，所以一定会移走。这样多了
一次移动。
另一种做法：在ADD命令中，我们也可以不区分，直接先加入min_heap，然后通过调整来移动。但是这样效率可能稍低。
我们按照上述经典实现。
注意：在C++中，priority_queue默认是最大堆，而最小堆需要指定比较函数：`priority_queue<int, vector<int>, greater<int>>`。
另外，我们需要考虑重复
元素的情况，但上述处理重复
元素没有问题。
现在，我们根据这个思路编写代码。
注意：题目要求模拟ADD和GET命令序列，并输出GET命令的结果。
示例命令序列：
ADD(3), GET(1), ADD(1), GET(2), ADD(-4), ADD(2), ADD(8), ADD(-1000), GET(3), GET(4), ADD(2)
我们期望的输出：
GET 1 -> 3
GET 2 -> 3
GET 3 -> -1000
GET 4 -> 1
但是，注意：在第
一个ADD(3)后，还没有GET命令，i=0。
ADD(3)
:
min_heap为
空，所以3加入max_heap。
然后调整：max_heap.size()=1>0（i=0），所以将3移到min_heap。此时max_heap为
空，min_heap=[3]。
然后第
一个GET：
i=1
调整：max_heap.size()=0<1，所以从min_heap取出3加入max_heap。此时max_heap=[3]，min_heap为
空。
输出3。
然后ADD(1)：
此时i=1（即已经完成1次GET）
min_heap为
空？不，现在min_heap为
空，所以1加入max_heap？但是条件：min_heap.empty()为真，所以进入if分支，将1加入max_heap。
现在max_heap=[1,3]? 不对，最大堆的性质：堆顶是最大的
元素，所以push(1)后，堆顶还是1（因为只有
一个元素？不对，push(1)后，堆中有1和3？不对，我们之前将3移到了min_heap，然后在GET时又移回来了，然后GET后max_heap=[3]（只有
一个元素），min_heap为
空。
现在ADD(1)：min_heap为
空，所以1加入max_heap（现在max_heap=[1,3]？实际上，C++的priority_queue（最大堆）在插入1和3后，堆顶是3（因为3>1）？不对，插入顺序是：先3（在GET时移入max_heap，然后GET后保留），然后ADD(1)时又插入1，所以堆中有1和3，堆顶是3（最大堆，最大的在堆顶）。
然后调整：max_heap的大小为2，而i=1（当前GET命令次数为1），所以需要调整：将堆顶3移出到min_heap。这样max_heap=[1]，min_heap=[3]。
然后GET(2)：
i=2
调整：max_heap.size()=1<2，所以从min_heap中取出3加入max_heap。此时max_heap=[3,1]（堆顶是3）? 注意：最大堆的存储顺序并不是有序的，但堆顶是最大值。所以此时max_heap的堆顶是3（因为3>1），而min_heap为
空。
输出3（即第2小的
元素是3？不对，因为当前
元素有3,1，第1小是1，第2小是3。所以正确。
然后继续添加：ADD(-4), ADD(2), ADD(8), ADD(-1000)
当前状态：i=2，max_heap=[3,1]（堆顶3）？不对，在GET(2)后，max_heap中
元素是1和3？实际上，在GET(2)调整时，我们从min_heap中取出3加入max_heap，所以max_heap中原来有1，现在加入3，所以有两个
元素：1和3，堆顶是3（最大堆，堆顶是最大值）。min_heap为
空。
ADD(-4)
:
因为min_heap为
空，所以-4加入max_heap。
现在max_heap
: 插入-4后，堆中有-4,1,3，堆顶是3（最大
元素）。
调整：max_heap的大小为3，而i=2（当前GET命令次数为2），所以需要将堆顶3移出到min_heap。这样max_heap=[1,-4]（堆顶是1，因为最大堆，所以堆顶是1和-4中较大的1），min_heap=[3]。
ADD(2)
:
min_heap的堆顶是3，2<3，所以2加入max_heap。
现在max_heap
: 插入2后，
元素有1,-4,2，堆顶是2（因为2>1>-4）。
调整：max_heap的大小为3>2，所以将堆顶2移出到min_heap。这样max_heap=[1,-4]（堆顶1），min_heap=[2,3]（堆顶2）。
ADD(8)
:
8>min_heap.top()=2，所以8加入min_heap。min_heap变为[2,3,8]（堆顶2）。
调整：max_heap的大小为2（等于i=2），所以不需要移动。
ADD(-1000)
:
-1000 < min_heap.top()=2，所以加入max_heap。
max_heap
: 插入-1000后，
元素有1,-4,-1000，堆顶是1（最大）。
调整：max_heap的大小为3>2，所以将堆顶1移出到min_heap。现在max_heap=[-4,-1000]（堆顶-4），min_heap=[1,2,3,8]（堆顶1）。
然后GET(3)：
i=3
调整：max_heap.size()=2<3，所以从min_heap中取出1加入max_heap。现在max_heap=[1,-4,-1000]（堆顶1），min_heap=[2,3,8]（堆顶2）。
输出1（堆顶）-> 第3小
元素是1？但是当前所有
元素：-1000, -4, 1, 2, 3, 8。排序后：-1000, -4, 1, 2, 3, 8。第3小是1，正确。
然后GET(4)：
i=4
调整：max_heap.size()=3<4，所以从min_heap中取出2加入max_heap。max_heap=[1,-4,-1000,2]（堆顶是2，因为最大堆，堆顶是最大值，所以2是这四个
元素中最大的，即第4小
元素是2？不对，因为第4小应该是2吗？排序后第4小是2，正确。所以输出2。
最后ADD(2)：
此时i=4（已经4次GET）
min_heap.top()=3，2<3，所以2加入max_heap。
max_heap
: 插入2后，
元素有2,1,-4,-1000,2（注意已经有
一个2了），堆顶是2（因为最大堆，堆顶是最大值，这里有两个2，但堆顶还是2）。
调整：max_heap的大小为5>4，所以将堆顶2移出到min_heap。这样max_heap=[2,1,-4,-1000]（堆顶是2，因为2>1），min_heap=[2,3,8]（堆顶2）。
所以，输出序列为：3, 3, 1, 2。
但是，注意题目中的示例GET命令的序号是1,2,3,4，所以输出就是按顺序的。
代码实现：
注意：我们使用两个堆和
一个整数i（表示已经完成的GET命令次数）。
命令序列：我们可以用一组命令（字符串和
整数）来表示。
例如：vector<pair<string, int>> commands = {
{"ADD", 3}, {"GET", 0}, {"ADD", 1}, {"GET", 0},
{"ADD", -4}, {"ADD", 2}, {"ADD", 8}, {"ADD", -1000},
{"GET", 0}, {"GET", 0}, {"ADD", 2}
};
注意：GET命令后面带的数字我们忽略，或者用0占位，因为GET命令没有参数（参数k由命令的序号决定）。
但是，在命令序列中，GET命令的序号是由它们在序列中的位置决定的（第1个GET，第2个GET...）。所以我们在处理GET命令时，只需要递增i。
因此，我们不需要记录GET命令的参数。
所以，命令序列可以这样定义：
vector<pair<string, int>> commands = {
{"ADD", 3}, {"GET", 0}, {"ADD", 1}, {"GET", 0},
{"ADD", -4}, {"ADD", 2}, {"ADD", 8}, {"ADD", -1000},
{"GET", 0}, {"GET", 0}, {"ADD", 2}
};
其中，GET命令的第二个参数没有用，可以忽略。
代码结构：
#include <iostream>
#include <queue>
#include <vector>
#include <string>
#include <functional> // for greater
using namespace std;
class BlackBox {
private
:
priority_queue<int> max_heap; // 最大堆，存储当前最小的i个
元素（堆顶是最大值）
priority_queue<int, vector<int>, greater<int>> min_heap; // 最小堆，存储其他
元素
int i; // 已经完成的GET命令次数
public
:
BlackBox() {
i = 0;
}
void add(int x) {
// 如果最小堆为
空，或者x小于最小堆的堆顶，则加入最大堆
if (min_heap.empty() || x < min_heap.top()) {
max_heap.push(x);
} else {
min_heap.push(x);
}
// 调整：如果max_heap的大小大于i，则将其堆顶移到min_heap
while (max_heap.size() > i) {
int top = max_heap.top();
max_heap.pop();
min_heap.push(top);
}
// 调整：如果max_heap的大小小于i，则从min_heap移动堆顶到max_heap
while (max_heap.size() < i && !min_heap.empty()) {
int top = min_heap.top();
min_heap.pop();
max_heap.push(top);
}
}
int get() {
i++; // 增加GET命令次数
// 调整：确保max_heap的大小等于i（当前GET命令的序号）
while (max_heap.size() < i && !min_heap.empty()) {
int top = min_heap.top();
min_heap.pop();
max_heap.push(top);
}
// 此时，最大堆的堆顶就是第i小的
元素
return max_heap.top();
}
};
int main() {
BlackBox box;
// 命令序列：
每个命令是
一个pair，第
一个元素是字符串，第二个
元素是
整数（ADD时是数字，GET时忽略）
vector<pair<string, int>> commands = {
{"ADD", 3}, {"GET", 0}, {"ADD", 1}, {"GET", 0},
{"ADD", -4}, {"ADD", 2}, {"ADD", 8}, {"ADD", -1000},
{"GET", 0}, {"GET", 0}, {"ADD", 2}
};
for (auto& cmd
: commands) {
if (cmd.first == "ADD") {
box.add(cmd.second);
cout << "ADD(" << cmd.second << ")" << endl;
} else if (cmd.first == "GET") {
int result = box.get();
cout << "GET
: " << result << endl; // 输出当前GET命令的结果
}
}
return 0;
}
运行这个程序，应该输出：
ADD(3)
GET
: 3
ADD(1)
GET
: 3
ADD(-4)
ADD(2)
ADD(8)
ADD(-1000)
GET
: 1
GET
: 2
ADD(2)
但是，注意：在第
一个GET命令后，我们输出3，第二个GET命令后输出3，第三个GET命令后输出1，第四个GET命令后输出2。
这符合我们的预期。
注意：在调整过程中，我们只处理了max_heap的大小小于i的情况（在GET命令中），而在ADD命令中我们处理了max_heap大小大于i的情况。这样保证了在GET命令时，max_heap的大小至少为i（如果
元素足够），并且我们通过移动使得大小等于i。
但是，在GET命令中，我们只移动了min_heap中的
元素到max_heap，而没有处理max_heap大小大于i的情况？因为GET命令中i增加了，所以max_heap的大小应该小于等于i（因为之前ADD命令调整时max_heap的大小等于原来的i，现在i增加了1，所以max_heap的大小小于新的i）。所以只需要从min_heap中补充
元素即可。
因此，上述实现正确。
注意：重复
元素的情况，以及边界情况（比如堆为
空）需要小心。但是上述代码在min_heap.empty()时已经做了判断。
我们运行测试。
如果遇到问题，可以添加一些调试输出（例如每次ADD和GET后打印两个堆的内容），但这里为了简洁，我们省略。
最后，按照要求，我们输出GET命令的结果。
注意：题目要求输出GET命令的结果，所以我们在GET命令时输出即可。
代码如上。</think>以下是用 C++ 实现 Black Box 数据库模拟器的完整代码，该程序处理 ADD 和 GET 命令，并输出 GET 命令对应的第 k 小
元素：
```cpp
#include <iostream>
#include <queue>
#include <vector>
#include <functional> // for std
::greater
class BlackBox {
private
:
std
::priority_queue<int> max_heap; // 最大堆，存储当前最小的 k 个
元素
std
::priority_queue<int, std
::vector<int>, std
::greater<int>> min_heap; // 最小堆，存储剩余
元素
int k_index = 0; // 已完成的 GET 命令计数
public
:
// 添加
元素到 Black Box
void add(int x) {
// 将新
元素插入到合适的堆中
if (min_heap.empty() || x < min_heap.top()) {
max_heap.push(x);
} else {
min_heap.push(x);
}
// 调整堆结构以维持平衡
// 如果最大堆
元素超过当前 k 值，将多余
元素移到最小堆
while (max_heap.size() > static_cast<size_t>(k_index)) {
int top = max_heap.top();
max_heap.pop();
min_heap.push(top);
}
// 如果最大堆
元素不足当前 k 值，从最小堆补充
元素
while (max_heap.size() < static_cast<size_t>(k_index) && !min_heap.empty()) {
int top = min_heap.top();
min_heap.pop();
max_heap.push(top);
}
}
// 获取第 k 小
元素（k = 当前 GET 命令序号）
int get() {
k_index++; // 增加 GET 命令计数
// 确保最大堆包含 k_index 个
元素
while (max_heap.size() < static_cast<size_t>(k_index) && !min_heap.empty()) {
int top = min_heap.top();
min_heap.pop();
max_heap.push(top);
}
return max_heap.top(); // 堆顶即为第 k 小
元素
}
};
int main() {
BlackBox box;
// 命令序列
: ADD 和 GET 操作
std
::vector<std
::pair<std
::string, int>> commands = {
{"ADD", 3}, {"GET", 0}, {"ADD", 1}, {"GET", 0},
{"ADD", -4}, {"ADD", 2}, {"ADD", 8}, {"ADD", -1000},
{"GET", 0}, {"GET", 0}, {"ADD", 2}
};
for (const auto& cmd
: commands) {
if (cmd.first == "ADD") {
box.add(cmd.second);
std
::cout << "ADD(" << cmd.second << ")" << std
::endl;
} else if (cmd.first == "GET") {
int result = box.get();
std
::cout << "GET
: " << result << " // 第" << box.get_k_index() << "小
元素" << std
::endl;
}
}
return 0;
}
```
### 关键实现说明：
1. **双堆结构**：
- `max_heap`（最大堆）：存储当前最小的 k 个
元素，堆顶为第 k 小
元素
- `min_heap`（最小堆）：存储剩余
元素，堆顶为最小的大于 max_heap 堆顶的
元素
- 使用 `std
::priority_queue` 实现，其中最小堆通过 `std
::greater` 比较器实现[^1]
2. **操作逻辑**：
- **ADD(x)**：
- 根据 x 与 `min_heap` 堆顶的比较决定插入位置
- 调整堆大小使 `max_heap` 保持 `k_index` 个
元素
- **GET()**：
- 递增 `k_index`（表示当前是第 k 个 GET 命令）
- 从 `min_heap` 移动
元素到 `max_heap` 直到满足 `max_heap.size() == k_index`
- 返回 `max_heap` 堆顶
元素
3. **时间复杂度**：
- ADD 操作：$O(\log n)$ 堆调整
- GET 操作：$O(\log n)$ 堆调整
- 总体效率：$O(n \log n)$ 处理 n 个命令
### 示例输出：
```
ADD(3)
GET
: 3 // 第1小
元素
ADD(1)
GET
: 3 // 第2小
元素
ADD(-4)
ADD(2)
ADD(8)
ADD(-1000)
GET
: 1 // 第3小
元素
GET
: 2 // 第4小
元素
ADD(2)
```
###
算法正确性验证：
对于输入序列 `[3, 1, -4, 2, 8, -1000, 2]`：
1. 第1小
元素：排序后为 `-1000, -4, 1, 2, 2, 3, 8` → 第1小=-1000（但首次 GET 时只有 3 和 1）
2. 实际执行过程：
- 首次 GET 前
元素：`[3]` → 第1小=3
- 第二次 GET 前
元素：`[3, 1]` → 排序 `[1,3]` → 第2小=3
- 第四次 GET 前
元素：`[-1000, -4, 1, 2, 3, 8]` → 第4小=2
###
本文介绍了一种利用异或运算快速找出数组中只出现一次元素的方法。通过遍历数组并逐个异或，最后剩余的结果即为只出现一次的数，时间复杂度为O(N)，空间复杂度为O(1)。
扫一扫
171
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
