浅谈C++|STL之set篇

最新推荐文章于 2024-05-14 01:36:48 发布
最新推荐文章于 2024-05-14 01:36:48 发布
阅读量3.1k 收藏 28
点赞数 6
文章标签： c++ java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73731708/article/details/132866349
版权

在这里插入图片描述

一.set

1.1set基本概念

特点：

所有元素在插入时，会自动排序，并且不能插入重复元素。

本质：

set/multiset属于关联式容器，底层是红黑树。

set/multiset区别

1.set不允许容器中有重复的元素
2.multiset允许容器中有重复的元素

1.2set构造和赋值

  1. 构造set容器：

    • 默认构造函数：std::set<Type> set_name;
    • 区间构造函数：std::set<Type> set_name(iterator_begin, iterator_end);
    • 拷贝构造函数：std::set<Type> set_name(another_set);
    • 拷贝构造函数（部分元素）：std::set<Type> set_name(another_set, iterator_begin, iterator_end);

  2. 赋值操作：

    • 拷贝赋值：set_name = another_set;
    • 移动赋值（自C++11起）：set_name = std::move(another_set);
    • 重载 = ：std::set<Type> set_name = another_set;

其中，Type是set中存储的元素类型。需要注意的是，set中的元素默认按照升序进行排序，并且所有元素都是唯一的。如果需要自定义排序规则或元素比较函数，可以使用带有自定义比较函数的构造函数和赋值操作符。

以下是一些示例代码：


// 构造set容器
std::set<int> mySet1;  // 默认构造函数

int arr[] = {1, 2, 3, 4, 5};
std::set<int> mySet2(arr, arr + 5);  // 区间构造函数，指针也可

std::set<int> anotherSet = mySet2;  // 拷贝构造函数

// 赋值操作
std::set<int> mySet3;
mySet3 = anotherSet;  // 拷贝赋值

std::set<int> mySet4;
mySet4 = std::move(anotherSet);  // 移动赋值
构造函数示例
默认构造函数std::set<Type> set_name;
区间构造函数std::set<Type> set_name(begin, end);
拷贝构造函数std::set<Type> set_name(another_set);
拷贝构造函数（部分元素）std::set<Type> set_name(another_set, iterator_begin, iterator_end);
赋值操作示例
拷贝赋值set_name = another_set;
移动赋值（自C++11起）set_name = std::move(another_set);

1.3set大小和交换

在STL中，set（或者其他关联容器）具有以下两个常用的成员函数来获取容器的大小以及交换容器内容：

  1. 大小操作：

    • size()：返回容器中元素的个数。
    • empty()：检查容器是否为空，如果为空则返回true，否则返回false。

  2. 交换操作：

    • swap()：将当前容器的内容与另一个容器进行交换。

以下是使用示例：

#include <iostream>
#include <set>

int main() {
  std::set<int> mySet = {1, 2, 3, 4, 5};

  // 大小操作
  std::cout << "Set的大小为：" << mySet.size() << std::endl;

  if (mySet.empty()) {
      std::cout << "Set为空" << std::endl;
  } else {
      std::cout << "Set不为空" << std::endl;
  }

  // 交换操作
  std::set<int> anotherSet = {10, 20, 30};
  mySet.swap(anotherSet);

  std::cout << "交换后的mySet：" << std::endl;
  for (const auto& num : mySet) {
      std::cout << num << " ";
  }
  std::cout << std::endl;

  std::cout << "交换后的anotherSet：" << std::endl;
  for (const auto& num : anotherSet) {
      std::cout << num << " ";
  }
  std::cout << std::endl;

  return 0;
}

输出结果：

Set的大小为：5
Set不为空
交换后的mySet：
10 20 30 
交换后的anotherSet：
1 2 3 4 5

通过调用size()函数可以获取set的大小，使用empty()函数可以判断set是否为空。而使用swap()函数可以交换两个set容器的内容。

大小操作说明
size()返回set容器中元素的个数。
empty()检查set容器是否为空，如果为空则返回true，否则返回false。
交换操作说明
swap(other_set)将当前set容器的内容与另一个set容器other_set进行交换。

1.4set的插入和删除

  1. 插入操作：

    • insert(val)：将值为val的元素插入set容器中。
    • insert(start, end)：将迭代器范围内的元素插入set容器中。
    • emplace(args)：在set容器中构造一个新元素，使用args参数传递构造参数。

  2. 删除操作：

    • erase(val)：从set容器中删除值等于val的元素。
    • erase(iterator)：删除按照迭代器指定的元素。
    • erase(start, end)：删除迭代器范围内的元素。
    • clear()：删除set容器中的所有元素。

以下是使用示例：

#include <iostream>
#include <set>

int main() {
  std::set<int> mySet;

  // 插入操作
  mySet.insert(1);
  mySet.insert(2);
  mySet.insert(3);

  mySet.emplace(4);

  std::set<int> anotherSet = {5, 6, 7};
  mySet.insert(anotherSet.begin(), anotherSet.end());

  // 删除操作
  mySet.erase(3);
  mySet.erase(mySet.find(4));
  mySet.erase(mySet.begin(), mySet.find(5));
  mySet.clear();

  return 0;
}

请注意，set是按照元素的自然排序进行存储的，因此在插入操作时会按照排序规则进行插入。在删除操作时，可以指定特定的元素值进行删除，或者使用迭代器进行删除，也可以删除迭代器范围内的一系列元素。使用clear()函数可以删除set容器中的所有元素。

插入操作说明
insert(val)将值为val的元素插入set容器中。
insert(start, end)将迭代器范围内的元素插入set容器中。
emplace(args)在set容器中构造一个新元素，并使用args参数传递构造参数。
删除操作说明
erase(val)从set容器中删除值等于val的元素。
erase(iterator)删除按照迭代器指定的元素。
erase(start, end)删除迭代器范围内的元素。
clear()删除set容器中的所有元素。

1.5set的查找和统计

在STL中，set（或其他关联容器）具有以下常用的成员函数来进行元素的查找和统计：

  1. 查找操作：

    • count(val)：返回set容器中值等于val的元素的个数（由于set中元素唯一，所以返回值只能是0或1）。
    • find(val)：返回一个迭代器，指向set容器中值等于val的元素，如果未找到则返回指向容器末尾的迭代器 end()。
    • lower_bound(val)：返回一个迭代器，指向set容器中第一个不小于val的元素。
    • upper_bound(val)：返回一个迭代器，指向set容器中第一个大于val的元素。
    • equal_range(val)：返回一个pair，包含两个迭代器，分别指向set容器中等于val的元素的起始位置和结束位置。

  2. 统计操作：

    • size()：返回set容器中元素的个数。

以下是使用示例：

#include <iostream>
#include <set>

int main() {
  std::set<int> mySet = {1, 2, 3, 4, 5};

  // 查找操作
  int count = mySet.count(3);
  std::cout << "值为3的元素在set中出现的次数：" << count << std::endl;

  auto it = mySet.find(4);
  if (it != mySet.end()) {
    std::cout << "找到了值为4的元素" << std::endl;
  } else {
    std::cout << "未找到值为4的元素" << std::endl;
  }

  auto lower = mySet.lower_bound(3);
  auto upper = mySet.upper_bound(3);
  std::cout << "大于等于3的第一个元素：" << *lower << std::endl;
  std::cout << "大于3的第一个元素：" << *upper << std::endl;

  auto range = mySet.equal_range(3);
  std::cout << "等于3的元素范围：" << *range.first << " - " << *range.second << std::endl;

  // 统计操作
  std::cout << "set的大小：" << mySet.size() << std::endl;

  return 0;
}

输出结果：

值为3的元素在set中出现的次数：1
找到了值为4的元素
大于等于3的第一个元素：3
大于3的第一个元素：4
等于3的元素范围：3 - 4
set的大小：5

通过以上示例可以看出，使用count()函数可以统计set容器中值等于给定值的元素个数。使用find()函数可以查找set容器中值等于给定值的元素，并返回其迭代器。lower_bound()函数可以返回第一个不小于给定值的元素的迭代器，而upper_bound()函数则返回第一个大于给定值的元素的迭代器。equal_range()函数返回一个pair，包含了等于给定值的元素的起始位置和结束位置。size()函数用于统计set容器中元素的个数。

查找操作说明
count(val)返回set容器中值等于val的元素的个数（返回值只能是0或1，因为set中元素唯一）。
find(val)返回一个迭代器，指向set容器中值等于val的元素，如果未找到则返回指向容器末尾的迭代器 end()。
lower_bound(val)返回一个迭代器，指向set容器中第一个不小于val的元素。
upper_bound(val)返回一个迭代器，指向set容器中第一个大于val的元素。
equal_range(val)返回一个pair，包含两个迭代器，分别指向set容器中等于val的元素的起始位置和结束位置。
统计操作说明
size()返回set容器中元素的个数。

1.6set的insert返回值

使用insert函数在set容器中插入元素时，返回值是一个pair类型的迭代器和布尔值。

  • 如果插入的元素在set容器中不存在（即唯一性），则返回的布尔值为true，且迭代器指向新插入的元素位置。
  • 如果插入的元素在set容器中已经存在（即已有相同的元素），则返回的布尔值为false，且迭代器指向与已存在的元素相等的位置。

以下是使用示例：

#include <iostream>
#include <set>

int main() {
  std::set<int> mySet = {1, 2, 3};

  auto result = mySet.insert(4);
  if (result.second) {
    std::cout << "插入成功，新元素的值为：" << *result.first << std::endl;
  } else {
    std::cout << "插入失败，重复的元素的值为：" << *result.first << std::endl;
  }

  result = mySet.insert(2);
  if (result.second) {
    std::cout << "插入成功，新元素的值为：" << *result.first << std::endl;
  } else {
    std::cout << "插入失败，重复的元素的值为：" << *result.first << std::endl;
  }

  return 0;
}

输出结果：

插入成功，新元素的值为：4
插入失败，重复的元素的值为：2

在上面的示例中，首先使用insert(4)插入一个在set容器中不存在的元素，因此返回的布尔值为true，迭代器指向新插入的元素位置。

接下来使用insert(2)插入一个已经存在的元素，由于set容器的唯一性特性，插入失败，返回的布尔值为false，迭代器指向与已存在的元素相等的位置。

1.7set自定义排序

在C++的STL中，set容器默认按照升序进行排序。在插入元素时，set容器会自动将元素按照特定的比较函数进行排序，以保证容器中的元素始终按照升序排列。

如果需要使用自定义的排序规则，可以在创建set容器时通过传递一个自定义的比较函数对象来指定排序规则。比较函数对象应满足严格弱排序（Strict Weak Ordering）的要求，即有传递性、反对称性和完全性。

例如，假设我们想要按照降序排列set容器中的元素，可以通过自定义比较函数对象来实现：

#include <iostream>
#include <set>

// 自定义的比较函数对象，仿函数
class DescendingComparator {
  bool operator()(int a, int b) const {
    return a > b;  // 降序排序
  }
};

int main() {
  std::set<int, DescendingComparator> mySet = {5, 2, 7, 1, 9};

  // 打印排序后的set容器内容
  for (const auto& elem : mySet) {
    std::cout << elem << " ";
  }
  std::cout << std::endl;

  return 0;
}

输出结果：

9 7 5 2 1

在上面的示例中，我们通过传递自定义的比较函数对象DescendingComparator来创建set容器mySet，从而实现按照降序排列的功能。

需要注意的是，通过自定义比较函数对象来指定排序规则时，当容器中的元素具有相等的排序键时，set容器仍然能够确保元素的唯一性。

const修饰的成员函数
bool operator()(int a, int b) const {
return a > b; // 降序排序
}

const成员函数具有以下几个特点：

  1. 不修改成员变量：const成员函数承诺不会修改类对象的成员变量的值。在const成员函数中，所有非静态的成员变量都被视为const，无法直接修改它们的值。只能访问成员变量的值或调用其他的const成员函数。

  2. 可以被常量对象调用：const成员函数可以被常量对象调用，而非const成员函数无法被常量对象调用。常量对象是指使用 const 修饰的对象，它们的成员函数只能调用对象的 const 成员函数。

  3. 重载：const成员函数和非const成员函数可以同时存在，并且可以根据是否为常量对象来进行重载。这样可以在不同的情况下调用不同的成员函数版本。

  4. 对象状态不变：const成员函数内部的逻辑不会改变对象的状态，也就是说，它不会修改对象的数据成员。这可以让使用者在调用const成员函数时，放心地假设对象不会被修改。

  5. 可以调用其他const成员函数：在const成员函数内部，可以调用其他的const成员函数。这是因为在const成员函数内部，所有的非静态成员变量都被视为const，因此只能调用const成员函数来保证对象状态的不变性。

总结起来，const成员函数由于其不修改对象状态的特性，能够提供更高的安全性和可靠性。它们可以被常量对象调用，不会修改对象的成员变量，可以重载非const成员函数，以及可以相互调用。

1.8set存储自定义类型

在C++中，可以使用std::set容器来存储自定义类型。

要在std::set中存储自定义类型，需要满足以下两个条件：

  1. 提供比较函数：std::set是一个有序容器，它要求元素能够进行比较来确定它们的顺序。为了实现自定义类型的比较，你可以通过重载小于运算符（<）或为该类型提供一个自定义的比较函数对象。这个比较函数或运算符将被用于确定元素的顺序。

    例如，假设有一个自定义类型 Person，我们可以重载 < 运算符来定义其比较方式，或者提供一个比较函数对象，如下所示：

    struct Person {
  std::string name;
  int age;

  // 通过重载 < 运算符定义比较方式
  bool operator<(const Person& other) const {
    return age < other.age;
  }
};

// 或者通过提供自定义的比较函数对象
struct AgeComparator {
  bool operator()(const Person& a, const Person& b) const {
    return a.age < b.age;
  }
};

  2. 为容器指定比较方式：在创建std::set对象时，需要指定元素的比较方式。你可以通过传递一个比较函数对象作为std::set的第二个模板参数，或者默认使用默认的比较方式（利用元素类型的 < 运算符）。例如：

    std::set<Person> people;  // 使用自定义比较函数对象
std::set<Person, AgeComparator> people;  // 使用自定义比较函数对象
std::set<int> numbers;  // 使用整数类型的默认比较方式

在存储自定义类型的std::set中，元素将按照它们的比较方式进行排序，保证元素的唯一性。你可以使用insert()函数向std::set中插入元素，使用find()函数在std::set中查找元素。同时，std::set还提供了其他常见的操作，如删除元素、遍历元素等。

1.9set函数接口

类别函数接口
构造函数set()
set(InputIt first, InputIt last)
set(const set& other)
set(set&& other)
赋值运算符operator=
operator=(set&& other)
迭代器begin()
end()
容量empty()
size()
max_size()
修改器insert(const value_type& value)
insert(InputIt first, InputIt last)
erase(const value_type& value)
erase(iterator position)
erase(iterator first, iterator last)
clear()
查找find(const value_type& value)
count(const value_type& value)
lower_bound(const value_type& value)
upper_bound(const value_type& value)
equal_range(const value_type& value)
比较operator==
operator!=
operator<
operator>
operator<=
operator>=

例子

operator<=是 std::set 容器的比较运算符之一，用于比较两个 std::set 是否满足部分顺序关系。下面是使用 operator<= 进行比较的方法：

首先，假设有两个 std::set 对象，例如 set1 和 set2。

std::set<T> set1;
std::set<T> set2;

要使用 operator<= 进行比较，只需要将这两个集合放在一个条件语句中，并使用 operator<= 进行比较。例如：

if (set1 <= set2) {
  // set1 是 set2 的子集或等于 set2
} else {
  // set1 不是 set2 的子集
}

当条件为真时，表示 set1 是 set2 的子集，或者两个集合完全相等。否则，当条件为假时，表示 set1 不是 set2 的子集。

请注意，这里的子集关系取决于 std::set 中元素的部分顺序关系，即集合中的元素按升序排列。

operator<=比较的是两个集合的关系，而不是集合中元素的值之间的关系。如果你想比较集合中的元素的值，请使用迭代器或其他比较方法进行元素比较。

二.multiset

std::set和std::multiset是C++标准库中的两种关联容器，它们的函数接口在大部分功能上是相同的，但在某些特定操作上有一些区别。

以下是std::set和std::multiset之间函数接口的主要区别：

  1. 插入操作：对于std::set，insert()函数返回一个std::pair对象，用于指示插入是否成功，并且如果插入的元素已经存在，则不会插入重复元素。而对于std::multiset，insert()函数直接插入元素，允许存储重复元素。

  2. 删除操作：erase()函数在std::set和std::multiset中的行为略有不同。在std::set中，erase()函数将删除与给定值相等的元素，并返回删除的元素数量（0或1）。在std::multiset中，erase()函数将删除所有与给定值相等的元素，并返回删除的元素数量。

  3. 元素计数：count()函数在std::set和std::multiset中的行为也略有不同。在std::set中，count()函数返回一个整数，表示与给定值相等的元素的数量（0或1）。而在std::multiset中，count()函数返回一个整数，表示与给定值相等的元素的数量。

  4. 查找操作：find()函数在std::set和std::multiset中的行为相同，都是用于在容器中查找与给定值相等的元素，并返回指向该元素的迭代器。如果找不到匹配的元素，则返回容器的end()迭代器。

除了上述区别外，std::set和std::multiset其他常见的函数接口，如迭代器操作、大小和容量查询等，基本上是相同的。

，这只是std::set和std::multiset之间在函数接口上的一些区别，它们共享相似的函数接口，因为它们都是基于相同的关联容器概念，并遵循C++标准库的通用规范。
下面是std::set和std::multiset之间函数接口的主要区别的整理表格：

函数接口std::setstd::multiset
插入操作insert()函数返回std::pair对象，不插入重复元素直接插入元素，允许存储重复元素
删除操作erase()函数删除等于给定值的元素，返回删除数量erase()函数删除等于给定值的所有元素，返回删除数量
元素计数count()函数返回0或1count()函数返回与给定值相等的元素数量
查找操作find()函数返回指向匹配元素的迭代器find()函数返回指向匹配元素的迭代器
其他常见操作迭代器操作、大小和容量查询等迭代器操作、大小和容量查询等

三.unordered_set

无序set

函数接口std::setstd::unordered_set
排序顺序元素按升序排列不对元素进行排序
插入操作insert()函数返回一个std::pair对象，不插入重复元素插入元素，不插入重复元素
查找操作find()函数返回指向匹配元素的迭代器find()函数返回指向匹配元素的迭代器
删除操作erase()函数删除等于给定值的元素并返回删除的数量erase()函数删除等于给定值的元素并返回删除的数量
元素计数count()函数返回值只能是0或1，因为集合中元素唯一count()函数返回与给定值相等的元素数量
迭代器范围遍历可以使用迭代器范围进行区间遍历可以使用迭代器范围进行区间遍历
内部实现基于红黑树实现，保持元素有序基于哈希表实现，元素无序
性能特点插入和删除操作相对较慢，查找操作较快插入和删除操作相对较快，查找操作速度由哈希函数质量决定
内存占用需要额外的存储空间来维护红黑树结构需要额外的存储空间来维护哈希表结构
迭代顺序根据元素值进行排序根据哈希函数和桶排序顺序，元素顺序不固定

unordered_set是基于哈希表实现的，因此在插入和查找操作时具有较快的平均时间复杂度。而set是基于红黑树实现的，保证了元素的有序性，但插入和删除操作相对较慢。在选择使用哪个容器时，可以根据实际需求和性能要求进行评估。

四.unordered_multiset

std::unordered_multiset是C++标准库中的一种关联容器，它实现了一个无序的、允许重复元素的集合（Multiset）。与std::unordered_set不同，std::unordered_multiset允许存储多个相同的元素，而不是将重复元素视为错误。

以下是std::unordered_multiset相较于std::unordered_set的一些主要特点和区别：

  1. 元素存储：std::unordered_multiset以无序的方式存储元素，并允许多个相同的元素存在。
  2. 插入重复元素：insert()函数可以插入重复的元素。
  3. 删除元素：erase()函数可以删除与给定值相等的所有元素。
  4. 元素计数：count()函数返回某个给定值在容器中的数量，可以用于统计重复元素的个数。
  5. 迭代器范围遍历：可以使用迭代器范围进行区间遍历，包括重复元素。

std::unordered_multiset使用哈希表（hash table）来实现存储和快速查找元素，而不会按照元素的顺序进行排序。如果你需要保持元素的有序性，请考虑使用std::multiset，它是一个有序的、允许重复元素的集合容器。

函数接口std::unordered_multisetstd::unordered_set
元素存储无序存储、允许重复元素无序存储、不允许重复元素
插入操作insert()函数可以插入重复元素insert()函数不插入重复元素
删除操作erase()函数删除与给定值相等的所有元素，并返回删除的数量erase()函数删除等于给定值的元素，并返回删除的数量
元素计数count()函数返回与给定值相等的元素数量count()函数返回0或1，因为集合中不存储重复项
迭代器范围遍历可以使用迭代器范围进行区间遍历，包括重复的元素可以使用迭代器范围进行区间遍历，不包括重复的元素
内部实现基于哈希表实现，元素无序基于哈希表实现，元素无序
性能特点插入和删除操作性能较快，查找操作速度取决于哈希函数和负载因子的质量插入和删除操作性能较快，查找操作速度取决于哈希函数和负载因子的质量
内存占用需要额外的存储空间来维护哈希表结构需要额外的存储空间来维护哈希表结构
迭代顺序元素的顺序是无序的元素的顺序是无序的

五.四种set总结

在C++中，有四种不同的集合容器：std::set、std::multiset、std::unordered_set和std::unordered_multiset。

  1. std::set：

    • 基于红黑树实现的有序集合容器。
    • 每个元素在容器中都是唯一的，不允许重复元素。
    • 元素按照升序存储，并且支持高效的查找、插入和删除操作。
    • 没有哈希函数的开销，也没有哈希冲突的问题。

  2. std::multiset：

    • 基于红黑树实现的有序多重集合容器。
    • 允许存储重复的元素，即可以有多个相等的元素。
    • 元素按照升序存储，并且支持高效的查找、插入和删除操作。

  3. std::unordered_set：

    • 基于哈希表实现的无序集合容器。
    • 每个元素在容器中都是唯一的，不允许重复元素。
    • 元素存储顺序是无序的，但在平均情况下，插入、查找和删除操作都具有较快的时间复杂度。
    • 元素类型需要提供哈希函数和相等比较函数。

  4. std::unordered_multiset：

    • 基于哈希表实现的无序多重集合容器。
    • 允许存储重复的元素，即可以有多个相等的元素。
    • 元素存储顺序是无序的，但在平均情况下，插入、查找和删除操作都具有较快的时间复杂度。
    • 元素类型需要提供哈希函数和相等比较函数。

总结来说，std::set和std::unordered_set是无序容器，而std::multiset和std::unordered_multiset是允许存储重复元素的无序容器。其中，std::set和std::multiset中的元素是有序存储的，而std::unordered_set和std::unordered_multiset中的元素是无序存储的，但具有更快的插入、查找和删除操作。选择使用哪种容器取决于你的需求，包括是否需要有序存储元素以及对性能的要求。

头文件：

  • std::set： #include <set>
  • std::multiset： #include <set>
  • std::unordered_set： #include <unordered_set>
  • std::unordered_multiset： #include <unordered_set>
左手的月光
关注
  • 6
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C++之STL
qq_42382539的博客
01-17 558
一、C++之STL概述 1）顺序容器----实现能按顺序访问的数据结构 array(C++11)----静态的连续数组 vector----动态的连续数组 deque----双端队列 forward_list(C++11)----单链表 list----双链表 2）关联容器----实现能快速查找（O（log n）复杂度）的数据结构 set/multiset----键的集合，按照键排序 map/multimap----键值对的集合，按照键排序 3）无序关联容器 unordered_set/unordered_
C++_STL之set容器使用方法
05-24
详细介绍C++中特殊容器——set容器的用法
C++中的Set的用法整理
热门推荐
gaoqiandr的博客
06-21 2万+
这是一篇针对不了解，不熟悉运用Set的小白用的，可以帮你更好的掌握这方面知识，进阶的话不太适合哦
2024年最新C++map和set的介绍及使用_c++ cmap set，阿里P8手把手教你
最新发布
2401_84978645的博客
05-14 1003
概念：set是按照一定次序存储元素的容器，这种次序使用set的迭代器遍历set中的元素，可以得到有序序列注：与map/multimap不同，map/multimap中存储的是真正的键值对，set中只放value，但在底层实际存放的是由构成的键值对2. 在set中，元素的value也标识它(value就是key，类型为T)，set中插入元素时，只需要插入value即可，不需要构造键值对，并且每个value必须是唯一的（可以使用set进行去重）
【总结】C++ 基础数据结构 —— STL之集合（set）用法详解
360°顺滑
10-05 1万+
文章目录一、set 的概念二、set 的基本操作三、set 的用法 一、set 的概念        set 的含义是集合，它是一个有序的容器，里面的元素都是排序好的，支持插入，删除，查找等操作，就像一个集合一样。所有的操作的都是严格在logn时间之内完成，效率非常高。set 和 multiset 的区别是：set 插入的元素...
Set详解
TestXzing的博客
06-15 321
学Java集合之Set集合，这一篇不看我替你遗憾
【C++ STL容器set 】std::set 的全方位解析
木牛的博客
04-10 2147
在深入探索 C++ 的set容器之前，让我们先建立一个坚实的基础，理解其基本概念和构成。set是一种关联容器，以其独特的方式，维护了元素的唯一性和有序性，为编程提供了强大而灵活的工具。set容器是标准模板库（Standard Template Library, STL）的一部分，设计用来存储唯一的元素，这些元素按照特定顺序排列。
C++ STL set详解
qq_34999565的博客
03-23 2535
template< class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> > class set; std::set是一种关联型容器，是一个排序集合，可以用来存放Key类型的对象。set集合里的对象都是唯一的，所以通常可以用set来做去重。其中排序是通过Compare这个对比函数对象来完成的，因为要排序，对于自定义类型需要告诉编译器这个...
STL中set用法
m0_73403047的博客
10-28 199
每个元素最多只出现一次，并且set中的元素已经从小到大排好序。所有元素都会在插入时自动被排序set st;//默认构造函数：//拷贝构造函数//重载等号操作符it!= s.end();it++)//构造和赋值//拷贝构造//赋值sets3;s3 = s2;test01();return 0;set容器插入数据时用insertset容器插入数据的数据会自动排序。
深入理解C++ STL库中的set容器
Yoyo的博客
08-09 561
C++ STL库是程序员在日常开发中常用的工具集，其中的set容器是一种非常有用的数据结构。本文将详细介绍C++ STL库中set容器的特点、用法以及内部实现机制，以帮助读者更好地理解和利用这一重要的容器。
STL之<set>
青竹梦
07-23 596
Set用于存储不重复的元素，若重复存入同一元素，则set会将其覆盖掉。 #include #include using namespace std; set h;//这个地方的int可以换为任意你想储存元素的类型 int main() { int n, x; cin >> n; h.clear();//这条语句的目的是清理h; for(int i = 0; i
浅谈c++ stl迭代器失效的问题
12-26
之前看《C++ Primier》的时候，也解到在顺序型窗口里insert/erase会涉及到迭代器失效的问题，并没有深究。今天写程序的时候遇到了这个问题。 1 莫名其妙的Erase 最初我的程序是酱紫的，别说话，我知道这样是有问题的...
c++ STL库容器之集合set代码实例
08-24
C++ STL库容器之集合set代码实例 在 C++ 中，STL（Standard Template Library）提供了多种容器类，其中set容器是一种标准关联容器，它的键值就是实值，实值就是键值，不可以有重复。set 容器使用平衡的搜索树——...
set_STL_C++_set_
10-04
在C++编程语言中，标准模板库（Standard Template Library，简称STL）是不可或缺的一部分，它提供了一系列高效、可重用的数据结构和算法。STL中的`set`容器是一个非常重要的部分，它允许我们存储唯一对象的集合，...
cpp代码-C++ STL之集合set的使⽤
07-16
本篇文章将详细探讨C++ STL中的集合set的使用。 首先，`#include <set>` 是使用set前需要包含的头文件。set容器内部实现为红黑树，保证了插入和查找操作的时间复杂度为O(log n)。集合set的主要特点有： 1. **唯一...
【C++基础】std::set详解
2201_75772333的博客
04-04 1579
std::set默认是根据元素的大小进行排序的，采用的是严格弱序（Strict Weak Ordering）的比较方式。这意味着元素必须支持运算符，元素按照升序排列。可以通过提供自定义的比较函数或者函数对象来实现排序规则。需要两个步骤：1、定义比较函数或者函数对象比较函数：定义一个函数，接受两个参数，比较它们的大小，并返回true或false，表示它们的顺序关系。函数对象（Functor）：定义一个类，重载operator()，使得对象可以像函数一样被调用，在其中实现比较逻辑。2、
set的常见用法详解
辉小歌的博客
03-24 1万+
目录set的定义set容器内元素的访问 set翻译为集合，是一个内部自动有序且不含重复元素的容器。在考试中，有可能出现需要去掉重复元素的情况，而且有可能因这些元素比较大或者类型不是int型而不能直接开散列表，在这种情况下就可以用set来保留元素本身而不考虑它的个数。当然，上面说的情况也可以通过再开一个数组进行下标和元素的对应来解决，但是set提供了更为直观的接口，并且加入set之后可以实现自动排序，因此熟练使用set可以在做某些题时减少思维量。 需要的头文件: #include<set>
浅谈C++ 之STL
weixin_44722531的博客
06-08 394
浅谈C++之STL 一、sort sort使用方便，效率较高，底层实现是用快排的方式进行排序 要使用该算法，需要#include 头文件(算法头文件） sort底层实现用的是快速排序 1. sort 用法一 对基本类型的数组从小到大排序: sort(数组名+n1，数组名+n2）; n1和n2都是int类型的表达式，可以包含变量 如果n1=0,则 + n1可以不写 将数组中下标范围为[n1,n2)的元素从小到大排序。下标为n2的元素不在排序 区间内 程序样例：对无序数组
C++ STL insert和emplace性能对比
qq_34999565的博客
03-24 1095
#include <chrono> #include <functional> #include <iomanip> #include <iostream> #include <set> #include <string> class Dew { public: Dew(int _a, int _b, int _c) : a(_a), b(_b), c(_c) { ...
c++stl之set
09-05
STL（标准模板库）中的set是一种基于红黑树的关联容器，它提供了一种快速查找、插入和删除元素的方式。 set中的元素是按照一定的顺序自动排序的，并且不允许存在重复的元素。这是通过红黑树的特性来实现的，红黑树是一种自平衡的二叉搜索树。 使用set时，我们可以通过insert()函数插入元素，.erase()函数删除元素。set自动对元素进行排序，使得插入和查找操作的复杂度都是O(logN)，其中N是集合中元素的个数。 set还提供了一些其他功能，如count()函数可以用来计算某个元素在集合中出现的次数，lower_bound()函数可以用来查找第一个不小于指定值的元素的位置，upper_bound()函数可以用来查找第一个大于指定值的元素的位置。 另外，set还可以用来解决一些需要查找和排序的问题。比如，我们可以使用set来对一组数据进行去重和排序，也可以使用set来实现一个优先级队列。 总的来说，set是一个非常有用的容器，它具有自动排序和去重的功能，适用于需要保持元素有序且无重复的场景。在面对需要进行高效查找、插入和删除操作的任务时，我们可以选择使用set来简化代码的实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

左手的月光

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值