Arrays 处理重复的数组元素

我在处理数组中的重复元素时遇到问题。例如，在查找数组中与指定值之和的所有整数对的问题中，以下是我的实现：

vector<pair<int, int>> find_all_pairs_with_sum(int data[], int length, int sum)
{
    assert(data && length>1);

    vector<pair<int, int>> res;

    sort(data, data+length);

    int first = 0; 
    int last = length - 1; 
    while (first < last) 
    { 
        int s = data[first] + data[last]; 
        if (s == sum) 
        {
            res.push_back(make_pair(data[first], data[last]));

            ++first; 
            --last; 
        } 
        else 
        { 
            if (s < sum)
                ++first; 
            else
                --last; 
        } 
    } 

    return res;
}

程序将只提供两对

（3,4）（3,4）

。但是，在这种情况下，正确答案应该是四对

（3,4）（3,4）（3,4）（3,4）（3,4）

（4=2x2）。如何修改代码以正确处理此类情况（希望仍处于

O（n logn）

）？在更新

first

和

last

时，似乎应该在

if（s==sum）

范围内进行更改，但我就是做不好

---

注意：我知道另一种可以正确处理这个问题的方法，即使用

哈希表来记录每个元素的出现情况。请建议如何在不使用
哈希表的情况下解决此问题
 您的数组被排序为

  Index: 0 1 2 3
Element: 3 3 4 4

当您找到一个和时，您会先递增
然后递减
最后一个
，因此每对只加一次，而不是两次。此外，无论如何，向内走都会阻止你同时得到1-3和0-2（按索引）。您可以进行初步传递以查找重复项，并使用该信息正确添加对：

vector<pair<int, int>> find_all_pairs_with_sum(int data[], int length, int sum)
{
    assert(data && length>1);

    vector<pair<int, int>> res;
    int i;

    sort(data, data+length);

    // there is more than one way to skin this cat...
    vector<pair<int, int>> vettedData;
    for(i = 0; i < length; i++) {
        if(i == 0 || vettedData[vettedData.size() - 1].first != data[i])
            vettedData.push_back(make_pair(data[i], 1));
        else
            vettedData[vettedData.size() - 1].second++;
    }

    int first = 0; 
    int last = vettedData.size() - 1; 
    while (first < last) 
    { 
        int s = vettedData[first].first + vettedData[last].first; 
        if (s == sum) 
        {
            int iterations = vettedData[first].second * vettedData[last].second;
            for(i = 0; i < iterations; i++)
                res.push_back(make_pair(vettedData[first].first, vettedData[last].first));

            ++first; 
            --last; 
        } 
        else 
        { 
            if (s < sum)
                ++first; 
            else
                --last; 
        } 
    } 

    return res;
}

vector find_all_pairs_与_sum（int data[]，int length，int sum）
{
断言（数据和长度>1）；
向量res；
int i；
排序（数据、数据+长度）；
//给这只猫剥皮的方法不止一种。。。
矢量数据；
对于（i=0；i
不，它仍然给出相同的两对。很好。当我运行它时，我实际上得到了3对，而不是2对。您必须搜索整个数组。这将成为
O（N^2）
。这并不是我想要的。然后你需要做一个初步的通行证才能找到重复。谢谢你的更新。但是，对于案例
{3,4,3}
和
sum=7
，它将失败。请检查一下。一个有趣的帖子：
vector<pair<int, int>> find_all_pairs_with_sum(int data[], int length, int sum)
{
    assert(data && length>1);

    vector<pair<int, int>> res;
    int i;

    sort(data, data+length);

    // there is more than one way to skin this cat...
    vector<pair<int, int>> vettedData;
    for(i = 0; i < length; i++) {
        if(i == 0 || vettedData[vettedData.size() - 1].first != data[i])
            vettedData.push_back(make_pair(data[i], 1));
        else
            vettedData[vettedData.size() - 1].second++;
    }

    int first = 0; 
    int last = vettedData.size() - 1; 
    while (first < last) 
    { 
        int s = vettedData[first].first + vettedData[last].first; 
        if (s == sum) 
        {
            int iterations = vettedData[first].second * vettedData[last].second;
            for(i = 0; i < iterations; i++)
                res.push_back(make_pair(vettedData[first].first, vettedData[last].first));

            ++first; 
            --last; 
        } 
        else 
        { 
            if (s < sum)
                ++first; 
            else
                --last; 
        } 
    } 

    return res;
}