精华内容
下载资源
问答
  • C++ std::set 出现重复元素

    千次阅读 2021-03-13 23:46:58
    如题,今天自定义了一个set的排序函数,重新构造了set,往里插入元素的时候居然出现了重复元素! 首先set的比较函数含义是按照元素的出现频率比较,高频率的大于低频率,如果二者频率相等,则数值小的大于数值大的...

    如题,今天自定义了一个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();
        }
    };
    展开全文
  • java:Set可以插入重复元素

    千次阅读 2020-10-23 19:12:01
    Set<List<Integer>> res1 = new HashSet<>(); res1.add(new ArrayList<>()); res1.add(new ArrayList<>(Arrays.asList(1))); Set<List<Integer>> ...

    在set中插入对象时,一定要新建对象,不要在已有对象上改,否则会出现插入重复对象的问题!

    先看这段代码:
    1,在set1中插入list1。
    2,在list1中插入元素2。
    3,在set1中插入list1,居然能插入重复元素!

    打印出list1的hashcode会发现,插入2前list1的hashcode=32,插入2后list1的hashcode=994。插入前后list1的hashcode不同,因此对set1来说是不同的元素,所以就诡异地成功插入了重复元素。

        public static void main(String[] args) {
            Set<List<Integer>> set1 = new HashSet<>();
            List<Integer> list1 = new ArrayList<>();
            list1.add(1);
            set1.add(list1);
    
            System.out.println("#1, set1=" + set1);
    
            System.out.println("list1 hashcode=" + list1.hashCode());
            list1.add(2);
            System.out.println("list1 exist=" + set1.contains(list1));
            set1.add(list1);
            System.out.println("list1 hashcode=" + list1.hashCode());
    
            System.out.println("#2, set1=" + set1);
    
        }
    

    输出

    #1, set1=[[1]]
    list1 hashcode=32
    list1 exist=false
    list1 hashcode=994
    #2, set1=[[1, 2], [1, 2]]
    
    展开全文
  • java 集合 Set 插入重复元素

    千次阅读 2019-05-04 13:21:35
    java 集合 Set 插入重复元素
                   


    class S{
     public int hashCode(){
      return 1;
     }
     public boolean equals(S s){
      return true;
     }
    }

    public class Test {
     
     @SuppressWarnings("unchecked")
     public static void main(String[] args) throws IOException {
      //ClassB b = new ClassB();
      //b.show();
      
      Set set = new HashSet();
      
      S s1 = new S();
      S s2 = new S();
      S s3 = new S();
      S s4 = new S();
      
      System.out.println(s1.equals(s2));
      
      set.add(s1);
      set.add(s2);
      set.add(s3);
      set.add(s4);
      
      
    //  set.add(new S());
    //  set.add(new S());
    //  set.add(new S());
    //  set.add(new S());
      
      System.out.println(set.size()); // 4    

      set不能重复说得是不能==,不是不能equals   先这样理解吧  


    //  S s1 = new S();
    //  S s2 = new S();
    //  
    //  System.out.println(s1.equals(s2));  

     

      


     }

    }

               
    展开全文
  • Set集合重复元素的判断

    千次阅读 2018-06-14 08:44:06
    更重要的是Set集合不能放置重复元素.她是怎么判断的呢?那么,我们首先要让对象具有比较性 一,存储的自定义对象实现接口 Comparable 复写public int compareTo()方法. 返回0表示二者相等. 如...

    Set集合比较特殊,他的方法基本上和Collection接口的方法一致,并且他没有根据索引得到对应值的get(int index)方法. 更重要的是Set集合不能放置重复的元素.她是怎么判断的呢?那么,我们首先要让对象具有比较性
    一,存储的自定义对象实现接口 Comparable
    复写public int compareTo()方法. 返回0表示二者相等. 如果返回大于0的整数(一般写1),则认为该对象大于比较的对象.如果返回小于0的整数(一般是-1),则认为该对象小于比较的对象.

    下面我们定义一个类Person,如果对象的年龄相等,我们就认为这两个对象相等

    public static void main(String[] args) {
            testTreeSet();
        }
    
        private static void testTreeSet() {
            TreeSet<Person> treeSet = new TreeSet<Person>();
            treeSet.add(new Person("Tom", 20));
            treeSet.add(new Person("Jim", 21));
            treeSet.add(new Person("Jim", 20));
    
            Iterator<Person> it = treeSet.iterator();
            while (it.hasNext()) {
                Person p = it.next();
                System.out.println(p.toString());
            }
            System.out.println("size = "+treeSet.size());
        }
    
        static class Person implements Comparable<Person> {
            private String name;
            private int age;
    
            public Person(String name, int age) {
                super();
                this.name = name;
                this.age = age;
            }
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            public int getAge() {
                return age;
            }
    
            public void setAge(int age) {
                this.age = age;
            }
    
            @Override
            public int hashCode() {
                System.out.println("hashcode  " + 17 * age);
                return 17 * age;
            }
    
            @Override
            public boolean equals(Object obj) {
                Person p = (Person) obj;
                boolean b = (this.age == p.getAge());
                if (b) {
                    System.out.println("一样      " + this.toString() + "   "
                            + p.toString());
                } else {
                    System.out.println("不一样      " + this.toString() + "   "
                            + p.toString());
                }
                return b;
            }
    
            @Override
            public String toString() {
                return "Person [name=" + name + ", age=" + age + "]";
            }
    
            @Override
            public int compareTo(Person o) {
                if (this.age == o.getAge()) {
                    return 0;
                }
    
                if (this.age > o.getAge()) {
                    return 1;
                }
    
                return -1;
            }
    
        }
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83

    运行结果为:
    Person [name=Tom, age=20]
    Person [name=Jim, age=21]
    size = 2

    由此分析,在操作treeSet.add(new Person(“Jim”, 20));的时候认为他是一个相同的对象,那么就无法再放入了

    二,存储的自定义对象实现接口 Comparable

    public static void main(String[] args) {
            testTreeSet();
        }
    
        private static void testTreeSet() {
            TreeSet<Person> treeSet = new TreeSet<Person>(new Comparator<Person>() {
                @Override
                public int compare(Person o1, Person o2) {
                    if (o1.getAge() == o2.getAge()) {
                        return 0;
                    }
    
                    if (o1.getAge() > o2.getAge()) {
                        return 1;
                    }
    
                    return -1;
                }
            });
            treeSet.add(new Person("Tom", 20));
            treeSet.add(new Person("Jim", 21));
            treeSet.add(new Person("Jim", 20));
    
            Iterator<Person> it = treeSet.iterator();
            while (it.hasNext()) {
                Person p = it.next();
                System.out.println(p.toString());
            }
            System.out.println("size = "+treeSet.size());
        }
    
        static class Person  {
            private String name;
            private int age;
    
            public Person(String name, int age) {
                super();
                this.name = name;
                this.age = age;
            }
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            public int getAge() {
                return age;
            }
    
            public void setAge(int age) {
                this.age = age;
            }
    
            @Override
            public String toString() {
                return "Person [name=" + name + ", age=" + age + "]";
            }
        }
    
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63

    结果是:
    Person [name=Tom, age=20]
    Person [name=Jim, age=21]
    size = 2
    存入了两个结果.
    treeSet.add(new Person(“Jim”, 20)); Jim的年龄和Tom相同被认为是一样的对象

    展开全文
  • 一:Set集合去掉List集合中重复元素 public static void main(String[] args) { //利用set集合 去除ArrayList集合中的重复元素 ArrayList list = new ArrayList(); list.add("1"); list.add("1"); list.add("2...
  • java中set集合如何去除重复元素

    万次阅读 2017-07-25 19:12:11
    set集合是可以重复元素集合; 用set集合添加一个学生对象元素时:import java.util.ArrayList; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Set;public class ...
  • c++中容器set的去除重复元素排序

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

    千次阅读 2018-01-15 10:07:38
    正如标题所说,set函数可以非常方便的将一个列表去重,例如 a = [1,2,3,4,4,2,3,31,3,3,2,4,313,1,21,21,3,3,22,2,2,2,3,3,3,4,4] b = set(a) print(a) print(b) 输出为 [1, 2, 3, 4, 4, 2, 3, 31, 3, 3,...
  • Java中利用Set判断List集合中是否有重复元素 1、在开发工作中,我们有时需要去判断List集合中是否含有重复的元素 2、我们不需要找出重复的元素,我们只需要返回一个 Boolean 类型就可以了 3、如果使用循环遍历的方式...
  • 使用ES6的Set去除数组的重复元素

    万次阅读 2017-06-02 11:13:39
    使用ES6的Set去除数组的重复元素方法一Array.from()方法可以将Set结构转化为数组结构function dedupe(array) { return Array.from(new Set(array)); }dedupe([1,2,3,3]);方法二扩展运算符(…)内部使用for…of循环...
  • Set解决重复数据问题

    千次阅读 2019-10-14 09:32:49
    HashSet实现set接口,实际上是由...set不允许重复元素,如果set已经有重复元素,会返回false。 案例,给定一个字符串,返回第一个重复的字符。 public static String findFirstRepeatedChar(String string) ...
  • C++学习-STL-容器--SET保存重复

    千次阅读 2019-08-16 14:53:44
    2、set集合中没有重复元素 当我们用set来保存自定义类对象的时候,我们需要规定比较规则,就是重载less<>(),因为set要排序,排序又要用到比较。 例子: class Test2 { public: Test2(int n):num(n) ...
  • Python中利用set去除列表(list)重复元素要处理一些数据,需要去除掉重复元素,比如列表a = [5, 2, 5, 1, 4, 3, 4],可以用如下方式实现 **a = [5, 2, 5, 1, 4, 3, 4] print list(set(a))**
  • Python去除列表中的重复元素

    万次阅读 多人点赞 2019-04-30 23:21:39
    1.使用set去除重复元素 list1 = [1, 2, 5, 6, 7, 4, 8, 2, 7, 9, 4, 6, 3] list2 = list(set(list1)) print(list2) 输出结果如下: 会改变原列表元素的顺序。 [1, 2, 3, 4, 5, 6, 7, 8, 9] 2.for循环语句 list1 = ...
  • 1、set创建 (1)非空集合两种创建方式 # 第一种创建方式 ...2、set中不存在重复元素 In [1]: set1 = set([1,2,3, 1, 2, 3, 'a', 'b', 'b']) In [2]: set1 Out[2]: {1, 2, 3, 'a', 'b'} 3、set不支持索引
  • set是一个元素不可以重复,无序的集合 #创建一个set #set一般都是通过内置函数来创建的 set1 = set() # 当{}有元素时, 如果元素时key:value形式, 认为是dict, 如果元素是单个的,认为是set集合 # 通过set()函数来...
  • Set集合如何判断重复元素

    千次阅读 2019-04-20 15:06:00
    1.TreeSet子类是利用Comparable接口来实现重复元素的判断,但是Set集合的整体特征就是不允许保存重复元素。 2.HashSet判断元素重复是利用Object类中的方法实现的: -|对象编码:public int hashCode(); -|对象....
  • 如何在Set集合中添加重复元素

    千次阅读 2020-03-22 00:16:43
    Set集合元素重复比较    当你把对象加入HashSet时,HashSet会先计算对象的hashcode值来判断对象加入的位置,同时也会与其他已经加入的对象的hashcode值作比较,如果没有相符的hashcode,HashSet会假设对象没有...
  • 去除Set集合中的重复元素

    千次阅读 2019-01-26 15:44:23
    去除 Set 集合的重复元素的方法与 equals(),hashCode()方法有关 class Person{ String name; int age; public String toString(){ return name+"..."+age; } } public class test1{ publi...
  • Set集合不允许存储重复元素原理

    千次阅读 2020-06-22 20:46:38
    Set集合不允许存储重复元素原理 package com.Set; import java.util.HashSet; /* Set集合不允许存储重复元素原理 */ public class Demo02HashSetSaveString { public static void main(String[] args) { //创建...
  • package set; import java.util.HashSet; public class HashSetDemo02 { ...List可以存放重复元素Set就是不重复的元素。 * @param args */ public static void main(String[] args) { H...
  • HashSet区分重复元素: 先使用hashcode方法判断已经存在HashSet中元素的hashcode值和将要加入元素hashcode值是否相同。如果不同,直接添加;如果相同,再调用equals方法判断,如果返回true表示HashSet中已经添加该...
  • [b]初学python,练习下set的...#找出字符串中的重复的字符 str='akwdlkandwm,nam,wndajbddaklwnldhawlhdlahndwla' dupstr=set() for i in str: if i in str: dupstr.add(i) print dupstr[/code] ...
  • set中的元素是不能相等重复的,这一点我知道,那么怎样才是(不)重复呢? 是hashcode相等?是地址相同?是元素的equal返回true? 猜测:先判断是不是同一个引用(地址),再判断equal 我自己做了...
  • java:求两个set中的相同元素

    千次阅读 2015-04-16 11:18:20
    使用java自带函数的方式: import java.util.HashSet;...import java.util.Set;public class Test { public static void main(String[] args) { Set<Integer> result = new HashSet(); Set<Integer>
  • Java中利用Set判断List集合中是否有重复元素

    万次阅读 多人点赞 2018-12-05 20:05:36
    在开发工作中,我们有时需要去判断List集合中是否含有重复元素 我们不需要找出重复元素,我们只需要返回一个Boolean类型就可以了 如果使用循环遍历的方式,将会消耗大量的性能 我们只需要将List集合转化为Set...
  • Set 集合类似于一个罐子,把一个对象添加到Set集合时,Set集合无法记住添加这个元素的顺序,所以Set里的元素不能重复(否则系统无法准确识别这个元素) List集合非常像一个数组,它可以记住每次添加元素的顺序,...
  • Set是Collection容器的一个子接口,它不允许出现重复元素,当然也只允许有一个null对象。 2、如何来区分重复与否呢?(how) “用iterator()方法来区分重复与否”,这是在网上流传的答案,个人认为这是个错误...
  • java为什么吗list允许存储重复元素,而set不允许存储重复元素

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 378,648
精华内容 151,459
关键字:

set重复元素