C++ 如何计算无序集合中的唯一整数？

这个问题可能看起来很琐碎，但我想知道在我将包含重复整数的数组转换为无序集合后，是否有一种方法可以获得唯一的整数计数。为了清楚起见，我从一个数组开始，变成一个无序集，突然，无序集只包含唯一的整数，我只是在无序集中重复的整数数之后。 这可能吗？（类似无序集计数（索引）？）

这个问题可能看起来很琐碎，但我想知道在我将包含重复整数的数组转换为无序集合后，是否有一种方法可以获得唯一的整数计数

如果容器是连续的，比如一个数组，那么我相信您可以使用

ptrdiff\u t

在进行一些迭代器运算后对它们进行计数。不过，我不确定非连续容器

因为您从一个数组开始：

调用数组

unique

返回

iter.end（）

使用

iter.begin（）

和

iter.end（）

请记住，步骤3中的计算需要针对

sizeof

和元素进行调整

---

但套用Beta，有些容器适用于此，而另一些则不适用。如果您有一个无序的集合（或一张地图或一棵树），那么信息将不容易获得。

根据您对用户2357112问题的回答，我将编写一个解决方案。 那么，让我们假设我们将使用一个向量，而不是无序的_集，我们的向量的值如下：

{1, 1, 1, 3, 4, 1, 1, 4, 4, 5, 5};

template <typename Type>
vector<Type> unique_entries (vector<Type> vec) { 
    for (auto iter = vec.begin (); iter != vec.end (); ++iter) { 
        auto f = find_if (iter+1, vec.end (), [&] (const Type& val) {
           return *iter == val; 
        });

        if (f != vec.end ()) { 
            vec.erase (remove (iter+1, vec.end (), *iter), vec.end ());
        }
    }
    return vec;
}

template <typename Type>
struct Properties { 
    Type key;
    long int count;
};

template <typename Type>
vector<Properties<Type>> get_properties (const vector<Type>& vec) { 
    vector<Properties<Type>> ret {};
    auto unique_vec = unique_entries (vec);
    for (const auto& uv : unique_vec) { 
        auto c = count (vec.begin (), vec.end (), uv); // (X)
        ret.push_back ({uv, c});
    }
    return ret;
}

template <typename Type>
void show (const vector<Properties<Type>>& vec) { 
    for (const auto& v : vec) { 
        cout << v.key << " " << v.count << endl;
    }
}

// usage below
vector<int> vec {1, 1, 1, 3, 4, 1, 1, 4, 4, 5, 5};
auto properties = get_properties (vec);
show (properties);

1 5
3 1
4 3
5 2

所以，我们想要得到（我认为是不同的向量）特定值在向量中出现多少次的数字，对吗？在这种情况下，结果是：1出现5次，3出现一次，4出现3次，5出现2次

要做到这一点，一个可能的解决方案如下：

{1, 1, 1, 3, 4, 1, 1, 4, 4, 5, 5};

template <typename Type>
vector<Type> unique_entries (vector<Type> vec) { 
    for (auto iter = vec.begin (); iter != vec.end (); ++iter) { 
        auto f = find_if (iter+1, vec.end (), [&] (const Type& val) {
           return *iter == val; 
        });

        if (f != vec.end ()) { 
            vec.erase (remove (iter+1, vec.end (), *iter), vec.end ());
        }
    }
    return vec;
}

template <typename Type>
struct Properties { 
    Type key;
    long int count;
};

template <typename Type>
vector<Properties<Type>> get_properties (const vector<Type>& vec) { 
    vector<Properties<Type>> ret {};
    auto unique_vec = unique_entries (vec);
    for (const auto& uv : unique_vec) { 
        auto c = count (vec.begin (), vec.end (), uv); // (X)
        ret.push_back ({uv, c});
    }
    return ret;
}

template <typename Type>
void show (const vector<Properties<Type>>& vec) { 
    for (const auto& v : vec) { 
        cout << v.key << " " << v.count << endl;
    }
}

// usage below
vector<int> vec {1, 1, 1, 3, 4, 1, 1, 4, 4, 5, 5};
auto properties = get_properties (vec);
show (properties);

1 5
3 1
4 3
5 2

从源向量中获取唯一条目，并将它们存储在不同的向量中，因此此向量将包含：1、3、4、5

迭代整个唯一向量，并从源向量中计算这些元素

打印结果

第1点的代码可以如下所示：

{1, 1, 1, 3, 4, 1, 1, 4, 4, 5, 5};

template <typename Type>
vector<Type> unique_entries (vector<Type> vec) { 
    for (auto iter = vec.begin (); iter != vec.end (); ++iter) { 
        auto f = find_if (iter+1, vec.end (), [&] (const Type& val) {
           return *iter == val; 
        });

        if (f != vec.end ()) { 
            vec.erase (remove (iter+1, vec.end (), *iter), vec.end ());
        }
    }
    return vec;
}

template <typename Type>
struct Properties { 
    Type key;
    long int count;
};

template <typename Type>
vector<Properties<Type>> get_properties (const vector<Type>& vec) { 
    vector<Properties<Type>> ret {};
    auto unique_vec = unique_entries (vec);
    for (const auto& uv : unique_vec) { 
        auto c = count (vec.begin (), vec.end (), uv); // (X)
        ret.push_back ({uv, c});
    }
    return ret;
}

template <typename Type>
void show (const vector<Properties<Type>>& vec) { 
    for (const auto& v : vec) { 
        cout << v.key << " " << v.count << endl;
    }
}

// usage below
vector<int> vec {1, 1, 1, 3, 4, 1, 1, 4, 4, 5, 5};
auto properties = get_properties (vec);
show (properties);

1 5
3 1
4 3
5 2

值得注意的是，本例使用模板编写，以提供在向量中选择元素类型的灵活性。如果要存储long、long、short等值，而不是int类型，则只需更改源向量的定义，例如：

vector<unsigned long long> vec2 {1, 3, 2, 3, 4, 4, 4, 4, 3, 3, 2, 3, 1, 7, 2, 2, 2, 1, 6, 5};
show (get_properties (vec2));

这是期望的结果

还有一个注意事项，您也可以使用字符串的向量来实现这一点

vector<string> vec_str {"Thomas", "Rick", "Martin", "Martin", "Carol", "Thomas", "Martin", "Josh", "Jacob", "Jacob", "Rick"};
show (get_properties (vec_str));

---

我假设您正在尝试获取唯一值的列表及其出现次数。如果是这样，那么

std:：map

提供了最干净、最简单的解决方案：

//Always prefer std::vector (or at least std::array) over raw arrays if you can
std::vector<int> myInts {2,2,7,8,3,7,2,3,46,7,2,1}; 

std::map<int, unsigned> uniqueValues;

//Get unique values and their count
for (int val : myInts)
    ++uniqueValues[val];

//Output:
for (const auto & val : uniqueValues)
    std::cout << val.first << " occurs " << val.second << " times." << std::endl;

//如果可以的话，请始终选择std:：vector（或至少是std:：array）而不是原始数组
std：：向量myInts{2,2,7,8,3,7,2,3,46,7,2,1}；
std：：映射唯一值；
//获取唯一值及其计数
for（int val:myInts）
++唯一值[val]；
//输出：
用于（常数自动和值：唯一值）
std:：cot假设我有数组
[2,1,2,1,2]
，我将它转换成一个无序集。您是在询问如何获取集合中的整数数（即2），还是试图获取每个整数出现的次数（因此2出现的次数将为3）？第一件事很简单，第二件事不是你会使用无序的集合。那么，集合中的所有值不是都是“唯一的”吗？这难道不是一个集合的定义要求之一，它将只包含每个“键”中的一个吗？你可能想阅读，例如，嗨，这是第二件事，。我可以使用无序地图做第二件事吗？）你可以使用无序地图，这样你可以记录每个数字出现的次数！使用
无序映射，而不是
无序映射集
。对于每个关键点，增加值。瞧！但我该怎么说呢？您是否有一个示例实现？Thanks@Lexka-我为您添加了更多信息。“你有一个示例实现吗？”-我希望你不是想让我为你实现这个：）嗨，实际上，我不是在处理数组，而是无序的集合，所以我认为你的示例不是appropriate@Lexka-你说你从一个数组开始：“…在我转换一个包含重复整数的数组之后…”你好，这是一个非常好且复杂的答案，但实际上我想要的是使用无序_图，因为人们之前明确表示使用无序_集是无用的。您知道如何使用无序的_映射而不从头开始编写代码吗？它最多应该是三行操作，不是吗？很抱歉，但目前我没有任何其他解决方案，尤其是使用无序图的解决方案。