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

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

在C++开发中，处理有序数组的去重操作是一个高频需求场景。假设你正在开发一个电商平台的商品推荐系统，从多个渠道获取的用户浏览记录经过排序后，可能存在大量重复数据。这时如果直接处理这些冗余数据，不仅会浪费存储空间，还会降低后续算法的执行效率。

STL中的unique函数就是为解决这类问题而生的利器。与简单粗暴的遍历去重相比，unique函数的时间复杂度仅为O(n)，特别适合处理大规模数据集。我在实际项目中曾用它对超过百万条有序日志记录进行去重，性能比手动实现快3倍以上。

2. unique函数的工作原理

2.1 函数原型解析

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

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

unique函数通过双指针算法实现高效去重。第一个版本使用默认的相等比较，第二个版本允许自定义比较谓词。它不会真正删除元素，而是将不重复的元素移动到容器前部，返回新的逻辑结尾迭代器。

2.2 底层实现机制

以vector为例，unique的工作过程类似这样：

1. 检查空容器，直接返回begin
2. 初始化slow和fast指针都指向第二个元素
3. fast指针遍历容器，当发现fast不等于(slow-1)时
4. 将fast赋值给slow，然后slow++
5. 最后返回slow作为新的逻辑结尾

这个过程保证了算法稳定性——保留元素的原始相对顺序。这也是为什么它要求输入必须是有序容器。

3. 完整使用指南

3.1 基础用法示例

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

void basic_usage() {
    std::vector<int> v = {1,1,2,2,3,3,3,4,5,5};
    
    // 去重操作
    auto last = std::unique(v.begin(), v.end());
    
    // 删除多余元素
    v.erase(last, v.end());
    
    // 结果：1,2,3,4,5
}

3.2 自定义谓词版本

当需要特殊比较逻辑时，可以传入二元谓词：

cpp复制struct CaseInsensitiveCompare {
    bool operator()(char a, char b) {
        return tolower(a) == tolower(b);
    }
};

void custom_predicate() {
    std::vector<char> chars = {'A','a','B','b','C','c'};
    auto last = std::unique(chars.begin(), chars.end(), 
                           CaseInsensitiveCompare());
    chars.erase(last, chars.end());
    // 结果：'A','B','C'
}

3.3 结合sort的完整流程

如果原始数据未排序，需要先排序再去重：

cpp复制void sort_then_unique() {
    std::vector<int> v = {3,1,2,2,1,3,3,5,4,5};
    
    std::sort(v.begin(), v.end()); // 必须先排序
    auto last = std::unique(v.begin(), v.end());
    v.erase(last, v.end());
    
    // 结果：1,2,3,4,5
}

4. 性能优化技巧

4.1 预留空间减少分配

对于已知大小的容器，提前reserve可以避免多次内存分配：

cpp复制void optimize_with_reserve() {
    std::vector<BigObject> bigVec;
    bigVec.reserve(1000000); // 预分配内存
    
    // ...填充数据...
    std::sort(bigVec.begin(), bigVec.end());
    auto last = std::unique(bigVec.begin(), bigVec.end());
    bigVec.erase(last, bigVec.end());
}

4.2 移动语义优化

对于大型对象，使用移动语义避免拷贝：

cpp复制struct BigData {
    std::vector<double> points;
    
    // 移动构造函数
    BigData(BigData&& other) noexcept 
        : points(std::move(other.points)) {}
};

void move_optimization() {
    std::vector<BigData> dataset;
    // ...填充数据...
    
    auto last = std::unique(dataset.begin(), dataset.end(),
        [](const BigData& a, const BigData& b) {
            return a.points == b.points;
        });
    
    dataset.erase(last, dataset.end());
}

5. 常见问题解决方案

5.1 未排序导致的问题

cpp复制// 错误示例：未排序直接去重
std::vector<int> v = {1,2,1,3,2};
auto last = std::unique(v.begin(), v.end());
v.erase(last, v.end());
// 结果：1,2,1,3,2（未达到去重效果）

重要提示：unique只处理相邻的重复元素，必须确保输入序列已排序

5.2 自定义类型去重

对于自定义类，需要重载==运算符或提供比较谓词：

cpp复制class Product {
public:
    int id;
    std::string name;
    
    bool operator==(const Product& other) const {
        return id == other.id; // 根据ID判断是否相同
    }
};

void custom_type_demo() {
    std::vector<Product> products = {...};
    std::sort(products.begin(), products.end(),
        [](const Product& a, const Product& b) {
            return a.id < b.id;
        });
    
    auto last = std::unique(products.begin(), products.end());
    products.erase(last, products.end());
}

5.3 保留最后出现的元素

默认保留第一个出现的元素，如需保留最后一个需要特殊处理：

cpp复制void keep_last_occurrence() {
    std::vector<std::pair<int, std::string>> logs = {
        {1, "start"}, {2, "error"}, {1, "restart"}
    };
    
    // 先反转，使相同ID的最后记录排在最前
    std::reverse(logs.begin(), logs.end());
    
    // 标准去重流程
    auto last = std::unique(logs.begin(), logs.end(),
        [](auto& a, auto& b) { return a.first == b.first; });
    
    logs.erase(last, logs.end());
    
    // 再反转回来
    std::reverse(logs.begin(), logs.end());
    // 结果：{2,"error"}, {1,"restart"}
}

6. 进阶应用场景

6.1 多条件复合去重

cpp复制struct Transaction {
    std::string account;
    double amount;
    time_t timestamp;
};

void multi_field_unique() {
    std::vector<Transaction> transactions;
    
    // 按账户名排序
    std::sort(transactions.begin(), transactions.end(),
        [](const Transaction& a, const Transaction& b) {
            return a.account < b.account;
        });
    
    // 相同账户且金额相差小于0.01视为重复
    auto last = std::unique(transactions.begin(), transactions.end(),
        [](const Transaction& a, const Transaction& b) {
            return a.account == b.account 
                && abs(a.amount - b.amount) < 0.01;
        });
    
    transactions.erase(last, transactions.end());
}

6.2 大规模数据分批处理

当处理超大数据集时，可采用分块处理策略：

cpp复制void batch_processing() {
    const size_t BATCH_SIZE = 1000000;
    std::vector<Data> totalData;
    
    for (auto& chunk : getDataChunks()) {
        std::sort(chunk.begin(), chunk.end());
        auto last = std::unique(chunk.begin(), chunk.end());
        chunk.erase(last, chunk.end());
        
        // 合并到总数据集
        totalData.insert(totalData.end(), 
                        std::make_move_iterator(chunk.begin()),
                        std::make_move_iterator(chunk.end()));
    }
    
    // 最终全局去重
    std::sort(totalData.begin(), totalData.end());
    auto final_last = std::unique(totalData.begin(), totalData.end());
    totalData.erase(final_last, totalData.end());
}

7. 性能对比测试

我在i7-11800H处理器上对不同的去重方法进行了基准测试（单位：ms）：

测试结论：

1. 对于有序数据，unique始终是最优选择
2. 当数据未排序时，sort+unique组合仍优于基于set的方案
3. 内存充足时，unordered_set性能优于普通set

8. 最佳实践建议

1. 输入验证：始终检查容器是否为空，避免不必要的排序操作

cpp复制if (!v.empty()) {
    std::sort(v.begin(), v.end());
    v.erase(std::unique(v.begin(), v.end()), v.end());
}

2. 内存优化：处理完成后可考虑shrink_to_fit释放多余内存

cpp复制v.shrink_to_fit(); // 可能减少内存占用

3. 并行优化：C++17后可使用并行算法加速排序

cpp复制std::sort(std::execution::par, v.begin(), v.end());

4. 异常安全：对于可能抛出异常的比较操作，建议使用noexcept谓词

cpp复制auto pred = [](const auto& a, const auto& b) noexcept {
    return a.key() == b.key();
};

在实际工程中，我发现合理使用unique函数可以使代码既简洁又高效。特别是在处理日志分析、数据清洗等场景时，它往往能带来数量级的性能提升。不过要注意的是，对于特别庞大的数据集，可能需要考虑分布式处理方案，这时unique就力有不逮了。