精华内容
下载资源
问答
  • set重复插入 std
    千次阅读
    2021-03-13 23:46:58

    如题,今天自定义了一个set的排序函数,重新构造了set,往里插入元素的时候居然出现了重复元素!

    首先set的比较函数含义是按照元素的出现频率比较,高频率的大于低频率,如果二者频率相等,则数值小的大于数值大的。

    unordered_map<int,int> ump;//统计元素频率
    struct cmp{
        bool operator()(int a,int b){
            //先比频率
            //再比数值
            if(a == b) return 0;
            return ump[a] == ump[b] ? a<b:ump[a]>ump[b];
        }
    };
    set<int,cmp> mp;
    void printmp()
    {
        //输出整个set
        for(auto c:mp) cout<<c<<":"<<ump[c]<<", ";
        cout<<endl;
    }
    int main() {
        vector<int> nums{1,2,2,1,3};
        for(int & num : nums)
        {
            ump[num]++;
            mp.insert(num);
            printmp();
        }
    };

    程序的运行结果如下:

    1:1,
    1:1, 2:1,
    2:2, 1:1, 2:2,
    2:2, 1:2, 2:2,
    2:2, 1:2, 2:2, 3:1,

    出现这个结果我思考了半天,首先怀疑了是不是自己定义的比较函数写错了,然而并没有写错。那么在这种比较函数中两个元素是如何判断等于的呢?简单来说就是将比较函数的参数互换如果得到相同的结果,就会判断为等于。放在set的实现中是不会将其插入的。

    那么问题出在哪里,就出在std::set的底层实现上,set的底层实现是红黑树,在判断是不是存在重复元素的时候,是从根节点开始向下遍历树节点访问的,如果向下访问中访问到了重复才不会插入,然而在我们的比较函数中,插入的时候1:1是比2:1要大的,也就是说2:1在1:1的左孩子上,而新加入的元素2:2是大于1:1的,因此红黑树添加到了1:1的右孩子节点,根本不会向左走去比较红黑树中已经存在的元素2,这时候set中就出现了重复元素。

    如果更正以上代码应该如下:

    unordered_map<int,int> ump;
    struct cmp{
        bool operator()(int a,int b){
            if(a == b) return 0;
            return ump[a] == ump[b] ? a<b:ump[a]>ump[b];
        }
    };
    set<int,cmp> mp;
    void printmp()
    {
        for(auto c:mp) cout<<c<<":"<<ump[c]<<", ";
        cout<<endl;
    }
    int main() {
        vector<int> nums{1,2,2,1,3};
        for(int & num : nums)
        {
            if(mp.find(num) != mp.end()) mp.erase(num);
            ump[num]++;
            mp.insert(num);
            printmp();
        }
    };
    更多相关内容
  • using namespace std; void OutPut(set<int> &s) { set<int>::iterator it; for(it=s.begin();it!=s.end();it++) cout<<" "<<*it<<", "; cout<<endl; } void ...

    std::set::insert

    函数原型:

    single element (1)		pair<iterator,bool> insert (const value_type& val);
    						pair<iterator,bool> insert (value_type&& val);
    with hint (2)			iterator insert (const_iterator position, const value_type& val);
    						iterator insert (const_iterator position, value_type&& val);
    range (3)				template <class InputIterator>
      						void insert (InputIterator first, InputIterator last);
    initializer list (4)	void insert (initializer_list<value_type> il);
    

    插入元素

    通过插入新元素来扩展容器,从而通过插入的元素数量有效地增加容器的大小。

    因为集合中的元素是唯一的,所以插入操作将检查每个插入的元素是否等效于容器中已经存在的元素,如果是,则不插入该元素,并向该现有元素返回迭代器(如果该函数返回一个值 )。

    有关允许重复元素的类似容器,请参见多集。

    在内部,集合容器使所有元素按照其比较对象指定的条件进行排序。 始终按照此顺序将元素插入其各自的位置。

    参数确定要插入多少个元素以及将它们初始化为哪些值:

    参数:
    val:
    要复制(或移动)到插入元素的值。

    成员类型value_type是容器中元素的类型,在set中定义为其第一个模板参数(T)的别名。

    position:
    请注意,这只是一个提示,并不强制将新元素插入到set容器内的该位置(集合中的元素始终遵循特定顺序)。

    成员类型iterator和const_iterator在map中定义为指向元素的双向迭代器类型。

    first,last:
    指定元素范围的迭代器。 范围为[first,last)的元素副本插入到容器中。

    请注意,范围包括first和last之间的所有元素,包括first指向的元素,但last指向的元素则不包括。

    函数模板参数InputIterator应该是一个输入迭代器类型,该类型指向可以从其构造value_type对象的类型的元素。

    il:
    一个initializer_list对象。 插入这些元素的副本。

    这些对象是根据初始值设定项列表声明符自动构造的。

    成员类型value_type是容器中元素的类型,在set中定义为其第一个模板参数(T)的别名。

    返回值:
    单个元素版本(1)返回一个对,其成员pair :: first设置为一个迭代器,该迭代器指向新插入的元素或集合中已经存在的等效元素。 如果插入了新元素,则对中的pair :: second元素设置为true,如果已经存在等效元素,则设置为false。

    带有提示(2)的版本将返回一个迭代器,该迭代器指向新插入的元素或集合中已经具有相同值的元素。

    成员类型迭代器是指向元素的双向迭代器类型。

    对是在中声明的类模板(请参见对)。


    std::multiset::insert

    函数原型:

    single element (1)		iterator insert (const value_type& val);
    						iterator insert (value_type&& val);
    with hint (2)			iterator insert (const_iterator position, const value_type& val);
    						iterator insert (const_iterator position, value_type&& val);
    range (3)				template <class InputIterator>
      						void insert (InputIterator first, InputIterator last);
    initializer list (4)	void insert (initializer_list<value_type> il);
    

    插入元素

    通过插入新元素来扩展容器,从而通过插入的元素数量有效地增加容器的大小。

    在内部,多集容器按照其比较对象所指定的标准对所有元素进行排序。 始终按照此顺序将元素插入其各自的位置。

    参数:
    val:
    要复制(或移动)到插入元素的值。

    成员类型value_type是容器中元素的类型,在多集中定义为其第一个模板参数(T)的别名。

    position:
    请注意,这只是一个提示,并不强制将新元素插入多集容器内的该位置(多集中的元素始终遵循特定顺序)。

    成员类型iterator和const_iterator在map中定义为指向元素的双向迭代器类型。

    first,last:
    指定元素范围的迭代器。 范围为[first,last)的元素副本插入到容器中。

    请注意,范围包括first和last之间的所有元素,包括first指向的元素,但last指向的元素则不包括。

    函数模板参数InputIterator应该是一个输入迭代器类型,该类型指向可以从其构造value_type对象的类型的元素。

    il:
    一个initializer_list对象。 插入这些元素的副本。

    这些对象是根据初始值设定项列表声明符自动构造的。

    成员类型value_type是容器中元素的类型,在多集中定义为其第一个模板参数(T)的别名。

    返回值:
    在返回值的版本中,这是一个指向多集中新插入元素的迭代器。

    成员类型迭代器是指向元素的双向迭代器类型。


    #include <iostream>
    #include <set>
    
    using namespace std;
    
    void OutPut(set<int> &s)
    {
    	set<int>::iterator	 it;
    	for(it=s.begin();it!=s.end();it++)
    		cout<<" "<<*it<<", ";
    	cout<<endl;	
    }
    
    void OutPutM(multiset<int> &s)
    {
    	multiset<int>::iterator	 it;
    	for(it=s.begin();it!=s.end();it++)
    		cout<<" "<<*it<<", ";
    	cout<<endl;	
    }
    
    void main()
    {
       set<int>s1;
       s1.insert(10);
       s1.insert(15);
       s1.insert(25);
       s1.insert(20);
       s1.insert(30);
       s1.insert(33);
       s1.insert(5);
       s1.insert(20);
       OutPut(s1);
    
       multiset<int>sm1;
       sm1.insert(10);
       sm1.insert(15);
       sm1.insert(25);
       sm1.insert(20);
       sm1.insert(30);
       sm1.insert(33);
       sm1.insert(5);
       sm1.insert(20);
       OutPutM(sm1);
    }
    

    在这里插入图片描述

    展开全文
  • using namespace std; int main() { set<int> s; s.insert(1); //返回值为pair<set<int>::iterator, bool> //迭代器表示该元素的位置 cout << *s.insert(1).first << endl; ...

    #include <iostream>
    #include <set>
    using namespace std;
    
    int main() {
        set<int> s;
        s.insert(1);
        //返回值为pair<set<int>::iterator, bool>
        //迭代器表示该元素的位置 
        cout << *s.insert(1).first << endl;
        cout << s.insert(1).second << endl; 
        //输出1 和 0 
    }

    STL中set的insert操作的返回值_可可西里-CSDN博客

     

    #include <iostream>
    #include <set>
    #include <string>
    #include <string.h>
    
    using namespace std;
    
    class Student
    {
    public:
    	Student(char*name,int age)
    	{
    		strcpy(this->name,name);
    		this->age=age;
    	}
    public:
    	int age;
    	char name[64];
    };
    
    //仿函数
    struct FuncStudent
    {
    	bool operator()(const Student&left,const Student &right)
    	{
    		if(left.age<right.age)//如果左边的值小就返回真,即从小到大安装年龄排序
    		{
    			return true;
    		}
    		else
    		{
    			return false;
    		}
    	}
    };
    
    int main()
    {
    	Student s1("s1",31);
    	Student s2("s2",22);
    	Student s3("s3",44);
    	Student s4("s4",11);
    	Student s5("s5",31);
    	set<Student,FuncStudent> set1;
    	//如何判断set1.insert()函数的返回值
    	//typedef pair<iterator, bool> _Pairib;
    	pair<set<Student,FuncStudent>::iterator,bool> pair1=set1.insert(s1);
    	if(pair1.second==true)
    	{
    		cout<<"插入s1成功"<<endl;
    	}
    	else
    	{
    		cout<<"插入s1失败"<<endl;
    	}
    	set1.insert(s2);
    	pair<set<Student,FuncStudent>::iterator,bool> pair5=set1.insert(s5);
    	if(pair5.second==true)
    	{
    		cout<<"插入s5成功"<<endl;
    	}
    	else
    	{
    		cout<<"插入s5失败"<<endl;
    	}
    
    	//遍历
    	for(set<Student,FuncStudent>::iterator it=set1.begin();it!=set1.end();it++)
    	{
    		cout<<it->age<<"\t"<<it->name<<endl;
    	}
    
    	system("pause");
    	return 0;
    }

     set容器(如何判断set.insert()函数的返回值)_liyuqian199695的博客-CSDN博客

    展开全文
  • Set 集合类似于一个罐子,把一个对象添加到Set集合时,Set集合无法记住添加这个元素的顺序,所以Set里的元素不能重复(否则系统无法准确识别这个元素) List集合非常像一个数组,它可以记住每次添加元素的顺序,...

    都是之前的博客了,发现草稿箱里面还有很多……

    Set的说明

    图示

    Set 集合类似于一个罐子,把一个对象添加到Set集合时,Set集合无法记住添加这个元素的顺序,所以Set里的元素不能重复(否则系统无法准确识别这个元素)

    List集合非常像一个数组,它可以记住每次添加元素的顺序,只是List长度可变。

    Map集合也像一个罐子,只是它里面的每项数据都由两个值组成。

     

    头文件

    #include      <set>

    定义

    set<string>   my_set; //string是关键字,类似map中的第一个,也可是char等数据类型

    迭代器

    set<string>::iterator set_it;//从声明可以看出指向关键字

     set_it=my_set.begin();//指向首

    Set的用法

    创建set对象
    为了管理set的二叉树链表数据,先用set容器的构造函数,创建一个set对象

    (1) set()
    用默认的less<T>函数对象和内存分配器,创建一个没有任何数据元素的set对象。
    set<int> s;  //创建了空的set对象s,元素类型为整型int;

    (2) set(const key_compare& comp)
    指定一个比较函数对象 comp 来创建set对象,内存分配器为默认值。
    //定义字符串比较函数对象 strLess
    struct strLess {
        bool operatro() (const char *s1, const char *s2) const
        {
             return strcmp(s1,  s2)  < 0;
         }
    };
    //创建set容器对象s
    set<const char*, strLess> s(strLess());

    (3)set(const set&)
    set拷贝构造函数,通过红黑树的拷贝构造函数,实现两个set容器的元素、头结点和节点个数的拷贝。
    //set<int> s1;
    set<int> s2 (s1);

    (4)set(InputIterator first, InputIterator last)
    用区间迭代器[first, last)所指的元素,创建一个set对象。
    int iArray = { 13, 32,19 };
    set<int> s(iArray, iArray+3);

    (5)set(InputIterator first, InputIterator last, const key_compare& comp)
    用区间迭代器[first, last)所指的元素和comp函数对象,创建一个set对象。
    const char* szArray = {"hello", "dog", "bird" };
    set<const char* , strLess> s(szArray, szArray+3, strLess() );

    元素的插入
    set没有尾部插入函数push_back(),元素的插入一般使用insert进行动态检索插入。

    注:

           (1)   //不可用下标方法插入遍历
           (2)   my_set.insert({‘a’}); //insert返回一个pair类型,第一个是一个迭代器指向元素,第二个是一个bool值,插入成功返回true,已经存在返回false
           (3)   vector<int> vec={2,4,6,8,10};my_set.insert(vec.begin(),vec.end()); 
           (4)   my_set.insert({1,2,3,4,5,6,7}); 


    (1)pair<iterator, bool> insert(const value_type& v)
    将元素v插入set容器,要求v值不与set容器的任何元素重复,否则插入失败。返回一个pair配对对象,提供所插入元素的迭代器位置和true/false插入成功标志。


    (2)iterator insert(iterator position, const value_type& v)
    将元素v插入set容器,参数position提示可在position位置之前插入v,所返回的插入位置视实际情况而定,不一定能在position位置之前插入。
    (3)void insert(inputIterator fist, InputIterator last)
    将某迭代器区间[first, last)所指的数据作为元素,插入到set容器。

    元素的删除
    与插入一样,set容器也具有高效的红黑树元素的删除处理, 并自动重新调整内部的红黑树平衡。

    (1)   my_set.erase(my_Itr); 
    (2)   my_set.erase("c");

      还是注意,第一种情况在迭代期间是不能被删除的,道理和foreach时不能删除元素一样。


    (1) void erase(iterator position)
    删除position所指的元素


    (2)size_type erase(const key_type& k)
    删除等于键值k的那个元素,对于set容器来说,此函数总是返回值1, 因为set容器不会出现重复的元素值(键值)。


    (3)void erase(iterator first, iterator last)
    删除set迭代器区间[first, last)上的所有元素。


    (4)void clear()
    删除所有元素,但不会删除内部红黑树的头节点。

    元素的遍历访问

    iterator begin();
    iterator  end();

    元素的反向遍历
    利用set容器定义的方向迭代器reverse_iterator和const_reverse_iterator,可实现红黑树的逆中序遍历,从而将元素从大到小遍历出来。
    reverse_iterator rbegin();
    reverse_iterator rend();

    元素的搜索
    set容器提供了一个应用红黑树进行搜索的函数find,返回的迭代器值为搜索到的元素位置,如果元素不存在,则返回end结束元素位置

    set容器的迭代器提供了访问内部红黑树中元素的操作,通常先用begin和end函数找出遍历开始的首元素和结束元素,然后通过迭代器的“++”操作,有小到到大取出元素值。

    set<char>::iterator   my_Itr=my_set.begin();           *my_Itr;//元素

     my_set.find('a');//返回迭代器,指向key=='a'的元素,若没有此元素返回my_set.end();

      my_set.count('a');//返回关键字等于'a'的数量,对已set不允许重复关键字,返回值永远是0或1
     不过注意,键本身是不能被修改的,除非删除。 

     迭代数据 
      for   (my_Itr=my_Map.begin();   my_Itr!=my_Map.end();   ++my_Itr)   {} 

     其它方法 
      my_set.size()               返回元素数目 
      my_set.empty()       判断是否为空 
      my_set.clear()           清空所有元素 
      可以直接进行赋值和比较:=,   >,   >=,   <,   <=,   !=   等等 

    set使用练习:输出字符中不重复的字符
     

    #include<set>
    int main()
    {
    char c;
    set<char> set_c;//创建set
    while(cin.get(c))
    set_c.insert(c);//插入,set不支持下标,insert返回pair,first指向元素,second是一个boll值,true表示插入成功,false表示已有元素
    set<char>::iterator iterator=set_c.begin();//创建迭代器指向首
    while(iterator!=set_c.end())
    {
    cout<<* iterator;//输出迭代器指向,只读,不可修改值
    iterator++;
    }
    }

    我对set所存疑难点

    相关例题

    Ugly numbers

    Ugly numbers are numbers whose only prime factors are 2, 3 or 5. The sequence 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, ... shows the first 11 ugly numbers. By convention, 1 is included. Write a program to find and print the 1500’th ugly number.

    Input

    There is no input to this program. Output Output should consist of a single line as shown below, with ‘’ replaced by the number computed. Sample

    Output

    The 1500'th ugly number is

    prime factor质因数

    分析
    题意:输出第1500个丑数(丑数:仅由质因数2,3,5相乘得来)

    来自一位大神的代码,感觉挺简单,用其他方法做的

    #include<cstdio>
    #include<cstring>
    #include<algorithm>
    using namespace std;
    int ugly[1510];
    int main()
    {
    		memset(ugly,0,sizeof(ugly));
    		int a,b,c;
    		a=b=c=1;
    		ugly[1]=1;
    		for(int i=2;i<=1500;i++)
    		{
    			ugly[i]=min(ugly[a]*2,min(ugly[b]*3,ugly[c]*5));
    			if(ugly[i]==ugly[a]*2)  a++;
    			if(ugly[i]==ugly[b]*3)  b++;
    			if(ugly[i]==ugly[c]*5)  c++;
    			
    		}
    
    		printf("The 1500'th ugly number is:<%d>\n",ugly[1500]);
    	return 0;
    }
    
    思路分析
    定义一个集合,该集合中有元素1,如果x在集合中,并且y是x的下一个丑数,那么x*2,x*3,x*5也在集合中,其它数不再集合中,这三个数中必定是2x最小,因此首先放入数组中,而此时*2最小的应该是x的下一个丑数y*2,此时应该找出y*2,x*3,x*5中最小的数放入数组,以此类推,具体操作如下:

                                                                                                      代码分析

     

    1.  1
    2. *2
    3. *3
    4. *5

      选出乘积最小的,加入到结果集中,相应指针右移  

    1.  1     2
    2. *3   *2
    3. *5

      选出乘积最小的,加入到结果集中,相应指针右移  

    1.  1     2    3
    2. *5   *2
    3. *3

      选出乘积最小的,加入到结果集中,相应指针右移  

    1. 1     2    3    4
    2. *5   *3    *2

      选出乘积最小的,加入到结果集中,相应指针右移  

    1. 1     2     3    4
    2. *3   *2
    3. *5

      以此类推,直到获得1500的结果集,实现代码如上

    这样就避免了有重复数字的问题,但是如果依次来求每一个丑数,有重复数字怎么做呢?

    我们用set来写一下这个代码

    #include<queue>
    #include<iostream>
    #include<vector>
    #include<set>
    using namespace std;
    typedef long long LL;
    const int a[3]={2,3,5};
    
    int main() {
    	priority_queue<LL,vector<LL>,greater<LL> > que;//从小到大
    	set<LL> s;
    	que.push(1);
    	s.insert(1);
    	for(int i=1;;i++) {
    		LL x=que.top();
    		que.pop();
    		if(i==1500) {
    			printf("The 1500'th ugly number is %lld.\n",x);
    			break;
    		}
    		for(int j=0;j<3;j++) {
    			LL y=x*a[j];
    			if(!s.count(y)) {
    				s.insert(y);
    				que.push(y);
    			}
    		}
    	}
    	return 0;
    } 

    当然,只要能AC,管他三七二十一,某位陈独秀的代码也AC了

    #include<iostream>
    using namespace std;
    
    int main() {
    	
    	printf("The 1500'th ugly number is 859963392");	
    	return 0;
    } 

    强大的一批……

     

    展开全文
  • std ; ll d [ NN ] ; ll canvis [ NN ] ; // can visit ll Cost [ NN ] [ NN ] ; ll Lvs [ NN ] ; // level bool vis [ NN ] ; ll Lv ; ll Lvlim ; ll N ; ll Min ; struct Node { int ...
  • c++中std::set自定义去重和排序函数

    千次阅读 2021-04-07 16:18:02
    c++中的std::set,是基于红黑树的平衡二叉树的数据结构实现的一种容器,因为其中所包含的元素的值是唯一的,因此主要用于去重和排序。这篇文章的目的在于探讨和分享如何正确使用std::set实现去重和排序功能。 方法一...
  • 除了存在key值重复导致的插入错误以外,还存在其他情况的插入错误,如operator的<条件没写全 求助:stl set除了key值重复还有哪些会导致insert失败的原因?-CSDN论坛 #include <iostream> #include &...
  • 3.8.4 set插入和删除

    2022-03-09 09:29:05
    //set容器插入和删除 void printSet(set<int>&s) { for (set<int>::const_iterator it = s.begin(); it != s.end(); it++) { cout << *it << " "; } cout << endl; ...
  • 多个点能创建几条直线; std::set<std::pair,double>>set和piar用于去重; std::multimap,double>按照value排序; int/int时*1.0 或 (double)int/int 来保证结果正确;
  • C++——std::Set

    2018-01-05 15:18:12
    写在前面: 在写这篇博客之前吐个槽,其实也可不不用这么麻烦这么写博客。讲道理其实在书本上学这些知识应该挺快的。可以书上看一遍记个大概,然后做题的过程中,不断遇见各种...那么这篇博客学习set容器。目前学习...
  • C++学习-STL-容器--SET保存重复

    千次阅读 2019-08-16 14:53:44
    2、set集合中没有重复的元素 当我们用set来保存自定义类对象的时候,我们需要规定比较规则,就是重载less<>(),因为set要排序,排序又要用到比较。 例子: class Test2 { public: Test2(int n):num(n) ...
  • 显然这个数据处理相当的繁琐,但是如果使用一个c++ STL的unordered_set容器的无重复元素的特性,就自动删除重复元素的项,最后留下来的容器内的元素个数,即为我们需要的答案。 代码: const static string MORSE[] ...
  • std::setstd::multiset使用总结

    千次阅读 2018-11-04 22:47:40
    Set和Multiset Set和Multiset的能力 Set和Multiset的操作函数 创建、复制和析构函数 非更易型操作(Nonmodifying Operating) 特殊的查找函数 ...插入和移除(Inserting and Removing) 异常处理   ...
  • std::set重复key 默认less排序 STL中的关联容器: std::set template< classKey, classCompare=std::less<Key>, classAllocator=std::allocator<Key> >classset; std::set是关联...
  • C++/C++11中std::set用法汇总

    万次阅读 2019-03-22 17:27:17
    std::pair<std::set<int>::const_iterator, std::set<int>::const_iterator> ret; ret = myset.equal_range(30); std::cout *ret.first ; std::cout *ret.second ; } { // erase:删除集合中的元素 std::set...
  • set插入和删除

    2021-02-03 13:39:31
    1.对set容器进行数据的插入和删除 2.函数原型 insert(elem); //在容器中插入数据 clear(); //清空容器中的数据 erase(pos); //擦除pos迭代器所指向的元素 erase(begin ,end); //擦除区间 [ begin, end) 区间内...
  • =虽然让多个重复的元素都在set中 #include <iostream> #include <set> using namespace std; class stru{ public: stru(int a, int b): x(a), y(b){} int x; int y; }; bool operator&...
  • std::map与std::set

    千次阅读 2016-03-13 12:28:56
    MAP的节点是一对数据. ...Map使用关键值Key来唯一标识每一个成员 map可以重复set是集合  都属于关联容器 只不过,map的形式 map mymap;  set的形式 set myset;  set(集合)——包
  • c++中向set集合中插入元素并遍历

    千次阅读 2019-08-11 18:21:51
    由于set集合容器实现了红黑...2.set集合内没有重复元素 ,只是对重复元素进行忽略处理,(multiset可以插入重复元素) 3.平衡二叉树采用中序遍历算法,于是,遍历时将键值由小到大排序 4.可以把平衡二叉树理解为:...
  • List封装了链表,Vector封装了数组, list和vector得最主要的区别在于vector使用连续内存存储的,他支持[]运算符,而list是以链表形式实现的,不支持[]。 Vector对于随机访问的速度很快,但是对于插入...Map,Set属于标
  • set不允许容器中有重复的元素 multiset允许容器中有重复的元素 2、函数原型 构造: set st; //默认构造函数: set(const set &st); //拷贝构造函数 赋值: set& operator=(const set &a
  • STL set的用法(获取插入结果)

    千次阅读 2018-08-10 10:04:41
    set是一个不允许重复的集合,如果要重复可以使用multiset。   1.set插入set.insert();】,会返回Pair&lt;iterator,bool&gt;对象,前一个是插入的位置,后一个是是否插入成功。     #include...
  • set集合中插入元素时,可根据set.insert().second的返回值判断集合中是否已有该元素。 #include<set> using namespace std; int main() { set<char>a; a.insert('a'); if(a.insert('a').second){ ...
  • C++ Set(集合)

    2021-01-06 22:20:50
    set 是一个内部自动有序且不含重复元素的容器。 set 最主要的作用就是自动去重并按升序排序,适用于需要去重但是又不方便直接开数组的情况。 set 中的元素是唯一的,其内部采用“红黑树”实现。 注:本文章只列举 ...
  • In this tutorial you will learn about stl unordered set container in c++ and various functions applicable on it. 在本教程中,您将学习c ++中的stl无序集合容器以及适用于它的各种功能。 Unordered Set ...
  • 1) 不能直接改变元素值,因为那样会打乱原本正确的顺序,要改变元素值必须先删除旧元素,则插入新元素2) 不提供直接存取元素的任何操作函数,只能通过迭代器进行间接存取,而且从迭代器角度来看,元素值是常数3) ...
  • c++中容器set的去除重复元素排序

    万次阅读 2018-08-22 15:28:05
    两者不同在于前者不允许元素重复,而后者允许。 1) 不能直接改变元素值,因为那样会打乱原本正确的顺序,要改变元素值必须先删除旧元素,则插入新元素 2) 不提供直接存取元素的任何操作函数,只能通过迭代器进行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,472
精华内容 7,788
关键字:

set重复插入 std