C++有序数组去重：unique函数原理与实践

1. 为什么需要有序数组去重？

在处理数据时，有序数组的去重操作有着广泛的应用场景。比如在数据库索引优化中，我们需要确保索引键的唯一性；在统计分析时，重复数据会影响结果的准确性；在算法竞赛中，去重往往是预处理的关键步骤。

C++标准库中的unique函数就是为这种场景量身定制的利器。与简单的遍历去重相比，unique函数有两大优势：首先，它针对已排序的序列进行了优化，时间复杂度仅为O(n)；其次，它返回去重后的新尾迭代器，方便我们直接截断容器。

注意：unique函数只能处理相邻的重复元素，因此必须确保输入序列是有序的。如果数组未排序，需要先调用sort函数。

2. unique函数的工作原理

2.1 函数原型解析

unique函数有两个常用重载版本：

cpp复制template<class ForwardIt>
ForwardIt unique(ForwardIt first, ForwardIt last);

template<class ForwardIt, class BinaryPredicate>
ForwardIt unique(ForwardIt first, ForwardIt last, BinaryPredicate p);

第一个版本使用operator==比较元素，第二个版本允许自定义二元谓词。函数返回指向去重后范围末尾的迭代器。

2.2 底层实现机制

unique函数的典型实现采用双指针策略：

1. 维护一个"写指针"指向当前唯一序列的末尾
2. 遍历数组，当遇到新元素时将其复制到写指针位置
3. 最后返回写指针的位置

这种实现保证了算法的高效性，只需要线性时间就能完成去重操作。

3. 完整使用示例

3.1 基础用法

cpp复制#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {1, 1, 2, 2, 2, 3, 4, 4, 5};
    
    // 必须先确保有序
    std::sort(v.begin(), v.end());
    
    // 去重操作
    auto last = std::unique(v.begin(), v.end());
    
    // 截断容器
    v.erase(last, v.end());
    
    // 输出结果
    for (int i : v) {
        std::cout << i << " ";
    }
    // 输出: 1 2 3 4 5
}

3.2 自定义比较函数

当需要根据特定条件去重时，可以使用自定义谓词：

cpp复制struct Point {
    int x, y;
};

int main() {
    std::vector<Point> points = {{1,2}, {1,2}, {2,3}, {2,3}, {3,4}};
    
    auto last = std::unique(points.begin(), points.end(),
        [](const Point& a, const Point& b) {
            return a.x == b.x && a.y == b.y;
        });
    
    points.erase(last, points.end());
}

4. 性能优化技巧

4.1 与sort配合使用

由于unique要求输入有序，通常需要先调用sort。对于大型容器，可以这样优化：

cpp复制std::vector<int> data = {...};

// 先排序
std::sort(data.begin(), data.end());

// 再原地去重
data.erase(std::unique(data.begin(), data.end()), data.end());

4.2 预分配空间

如果知道大概的唯一元素数量，可以先reserve空间：

cpp复制std::vector<int> result;
result.reserve(estimated_unique_count);
std::unique_copy(sorted.begin(), sorted.end(), std::back_inserter(result));

5. 常见问题与解决方案

5.1 为什么去重后容器大小没变？

unique函数只是将重复元素移到容器末尾并返回新结尾迭代器，要真正缩小容器需要配合erase：

cpp复制vec.erase(std::unique(vec.begin(), vec.end()), vec.end());

5.2 处理自定义类型

对于自定义类型，需要确保：

1. 实现了operator==
2. 或者提供自定义比较谓词
3. 类型是可移动构造和可移动赋值的

5.3 多条件去重

当需要根据多个字段去重时，可以这样定义谓词：

cpp复制auto predicate = [](const Person& a, const Person& b) {
    return a.name == b.name && a.age == b.age;
};
std::unique(persons.begin(), persons.end(), predicate);

6. 与其他去重方法对比

6.1 使用set去重

cpp复制std::set<int> s(vec.begin(), vec.end());
vec.assign(s.begin(), s.end());

优点：代码简单
缺点：破坏了原始顺序，且时间复杂度为O(n log n)

6.2 手动遍历去重

cpp复制std::vector<int> result;
for (int x : sorted) {
    if (result.empty() || result.back() != x) {
        result.push_back(x);
    }
}

优点：可控性强
缺点：需要自己处理边界条件

相比之下，unique函数在保持顺序和性能之间取得了最佳平衡。

7. 实际应用案例

7.1 日志数据去重

处理服务器日志时，经常需要去除重复条目：

cpp复制void dedupLogs(std::vector<LogEntry>& logs) {
    // 按时间戳排序
    std::sort(logs.begin(), logs.end(), 
        [](const LogEntry& a, const LogEntry& b) {
            return a.timestamp < b.timestamp;
        });
    
    // 根据内容去重
    logs.erase(std::unique(logs.begin(), logs.end(),
        [](const LogEntry& a, const LogEntry& b) {
            return a.content == b.content;
        }), logs.end());
}

7.2 数据库结果集处理

从数据库查询出的结果可能需要去重：

cpp复制std::vector<Record> getUniqueRecords() {
    std::vector<Record> records = queryDatabase();
    std::sort(records.begin(), records.end());
    records.erase(std::unique(records.begin(), records.end()), records.end());
    return records;
}

8. 高级用法与扩展

8.1 与move语义结合

C++11后，unique可以利用move语义提高性能：

cpp复制std::vector<std::string> words = {...};
std::sort(words.begin(), words.end());
words.erase(std::unique(words.begin(), words.end()), words.end());

对于大型对象，这可以避免不必要的拷贝。

8.2 并行化处理

对于超大数组，可以考虑并行排序后去重：

cpp复制std::vector<int> bigData(1000000);

// 并行排序
std::sort(std::execution::par, bigData.begin(), bigData.end());

// 串行去重
bigData.erase(std::unique(bigData.begin(), bigData.end()), bigData.end());

9. 性能测试数据

在以下环境下测试不同去重方法的性能（单位：ms）：

测试环境：Intel i7-9700K, 32GB RAM, GCC 11.2

10. 最佳实践总结

1. 始终确保输入序列是有序的
2. 记得使用erase截断容器
3. 对于自定义类型，提供合适的比较方法
4. 考虑使用reserve预分配空间
5. 大型数据集可以先并行排序再串行去重
6. 多字段去重时定义清晰的谓词函数

在实际项目中，我通常会封装一个通用的去重函数：

cpp复制template<typename T>
void removeDuplicates(std::vector<T>& vec) {
    std::sort(vec.begin(), vec.end());
    vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
}

对于特别大的数据集，可以考虑分批处理或者使用基于磁盘的外部排序算法，但unique函数在大多数情况下都能提供最佳的性能和简洁性平衡。