精华内容
下载资源
问答
  • 交集并集

    2012-01-31 11:48:37
    //输入集合A、B和全集C,求两集合的交集并集、补集、差集 /* 并集:以属于A或属于B的元素为元素的集合成为A与B的并(集) 交集: 以属于A且属于B的元素为元素的集合成为A与B的交(集) 差:以属于A而不属于B...

     http://www.cppleyuan.com/viewthread.php?tid=4457

    //输入集合A、B和全集C,求两集合的交集、并集、补集、差集

    /*
    并集:以属于A或属于B的元素为元素的集合成为A与B的并(集)
    交集: 以属于A且属于B的元素为元素的集合成为A与B的交(集)
    差:以属于A而不属于B的元素为元素的集合成为A与B的差(集)
    补集:A的补集C-B
    */
    /*
    例如:A={1,2,3} B={2,3,4} C={1,2,3,4,5}
    AB并集为={1,2,3,4}
    交集为={2,3}
    A补集={4,5}
    AB差集为={1}

    */
    #include <iostream>
    #include <vector>
    using namespace std;

    int main()
    {
            vector<int> A,B,C;
            int temp;
           
            cout<<"input A,finished by a character"<<endl;
            while(cin>>temp)
                    A.push_back(temp);
            cin.clear() ;//清除错误状态
            cin.ignore() ;//跳过无效数据
           
           
            cout<<"input B,finished by a character"<<endl;
            while(cin>>temp)
                    B.push_back(temp);
            cin.clear() ;
            cin.ignore() ;
           
           
            cout<<"input C,finished by a character"<<endl;
            while(cin>>temp)
                    C.push_back(temp);
            cin.clear();
            cin.ignore();
           
           
           
            //求交集
            vector<int> AND;
           
           
            for(int i=0;i<A.size();i++)
                    for (int j=0;j<B.size();j++)
                            if(A[i]==B[j])
                                    AND.push_back(B[j]);
            cout<<"交集为"<<endl;
            //显示交集
            for(i=0;i<AND.size();i++)
                    cout<<AND[i]<<" ";
            cout<<endl;
                           
            //求并集
            AND.clear();

            //先把A的元素依次加入
            for(i=0;i<A.size();i++)
                    AND.push_back(A[i]);
           
            //加入B中有且与A的每一个元素都不相等的元素
           
            for(int j=0;j<B.size();j++)
            {
                    int k=0;
                    for(i=0;i<A.size();i++)
                            if(B[j]!=A[i])
                                    k++;
                    if(k>=A.size())
                            AND.push_back(B[j]);
            }

            //显示并集               
            cout<<"并集为"<<endl;
            for(i=0;i<AND.size();i++)
                    cout<<AND[i]<<" ";
            cout<<endl;
                                   
            return 0;
    }

     

    展开全文
  • js Array 交集 并集 差集 去重.pdf
  • 主要介绍了pandas DataFrame 交集并集补集的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 利用指针来实现动态数组,求两个集合的交集和并集。(要求用动态数组来实现)依次分别输入数组A、B长度,并输入A,B中元素,即可得到交集并集
  • import java.util.ArrayList; import java.util.List;... * list 交集 并集 差集 去重并集 **/ public class CollectionsTest { public static void main(String[] args) { List<String> list1 = new Array.
    
    import java.util.ArrayList;
    import java.util.List;
    
    import static java.util.stream.Collectors.toList;
    
    /**
     * list 交集 并集  差集 去重并集
     **/
    public class CollectionsTest {
        public static void main(String[] args) {
            List<String> list1 = new ArrayList<>();
            list1.add("1");
            list1.add("2");
            list1.add("3");
            list1.add("4");
            list1.add("5");
    
            List<String> list2 = new ArrayList<>();
            list2.add("2");
            list2.add("3");
            list2.add("6");
            list2.add("7");
            list2.add("8");
    
            // 交集
            List<String> intersection = list1.stream().filter(item -> list2.contains(item)).collect(toList());
            System.out.println("---交集 intersection---");
            intersection.parallelStream().forEach(System.out::println);
    
            // 差集 (list1 - list2)
            List<String> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(toList());
            System.out.println("---差集 reduce1 (list1 - list2)---");
            reduce1.parallelStream().forEach(System.out::println);
    
            // 差集 (list2 - list1)
            List<String> reduce2 = list2.stream().filter(item -> !list1.contains(item)).collect(toList());
            System.out.println("---差集 reduce2 (list2 - list1)---");
            reduce2.parallelStream().forEach(System.out::println);
    
            // 并集
            List<String> listAll = list1.parallelStream().collect(toList());
            List<String> listAll2 = list2.parallelStream().collect(toList());
            listAll.addAll(listAll2);
            System.out.println("---并集 listAll---");
            listAll.parallelStream().forEachOrdered(System.out::println);
    
            // 去重并集
            List<String> listAllDistinct = listAll.stream().distinct().collect(toList());
            System.out.println("---得到去重并集 listAllDistinct---");
            listAllDistinct.parallelStream().forEachOrdered(System.out::println);
    
        }
    
    }
    
    展开全文
  • java8 lambda表达式 实现 java list 交集 并集 差集 去重复并集java8 lambda表达式 实现 java list 交集 并集 差集 去重复并集 java8 lambda表达式 实现 java list 交集 并集 差集 去重复并集 javaList 交、并集采用...

    java8 lambda表达式 实现 java list 交集 并集 差集 去重复并集

    java8 lambda表达式 实现 java list 交集 并集 差集 去重复并集

    javaList 交、并集采用简单的 removeAll retainAll 等操作,不过这也破坏了原始的javaList对象,采用java8 lambda表达式流操作则可以不影响原始list对象而得到两个javaList对象的 交、并、差集。

    1、简单两个List 交、并、差集

    /**
         * 简单类型的处理
         */
        public static void showSimpleDeal() {
            List<String> list1 = new ArrayList<>();
            list1.add("1111");
            list1.add("2222");
            list1.add("3333");
    
            List<String> list2 = new ArrayList<>();
            list2.add("3333");
            list2.add("4444");
    
            Set<String> list1Set = new HashSet<>(list1);
    
            Set<String> list2Set = new HashSet<>(list2);
    
            // 交集
            List<String> intersection = list1.stream().filter(list2Set::contains).collect(Collectors.toList());
            System.out.println("---得到交集 intersection---");
            intersection.parallelStream().forEach(System.out::println);
    
            // 差集 (list1 - list2)
            List<String> reduce1 = list1.stream().filter(item -> !list2Set.contains(item)).collect(Collectors.toList());
            System.out.println("---得到差集 reduce1 (list1 - list2)---");
            reduce1.parallelStream().forEach(System.out::println);
    
            // 差集 (list2 - list1)
            List<String> reduce2 = list2.stream().filter(item -> !list1Set.contains(item)).collect(Collectors.toList());
            System.out.println("---得到差集 reduce2 (list2 - list1)---");
            reduce2.parallelStream().forEach(System.out::println);
    
            // 并集
            List<String> listAll = list1.parallelStream().collect(Collectors.toList());
            List<String> listAll2 = list2.parallelStream().collect(Collectors.toList());
            listAll.addAll(listAll2);
            System.out.println("---得到并集 listAll---");
            listAll.parallelStream().forEach(System.out::println);
    
            // 去重并集
            list1Set.addAll(list2Set);
            List<String> listDistinctAll = new ArrayList<>(list1Set);
            System.out.println("---得到去重并集 listDistinctAll---");
            listDistinctAll.parallelStream().forEach(System.out::println);
    
            System.out.println("---原来的List1---");
            list1.parallelStream().forEach(System.out::println);
            System.out.println("---原来的List2---");
            list2.parallelStream().forEach(System.out::println);
        }
    

    2、List 与List交、差集

    static class User {
            public String name = "";
            public int age=0;
    
            public int getAge() {
                return age;
            }
    
            public void setAge(int age) {
                this.age = age;
            }
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
        }
        public static void main(String[] args) {
            List<User> list1 = new ArrayList();
            User user1=new User();
            user1.setName("A运营");
            user1.setAge(12);
            list1.add(user1);
            User user2=new User();
            user2.setName("B运营");
            user2.setAge(22);
            list1.add(user2);
            User user3=new User();
            user3.setName("E运营");
            user3.setAge(32);
            list1.add(user3);;
    
           
    
            List<String> list2 = new ArrayList();
            list2.add("B运营");
            list2.add("C运营");
            list2.add("D运营");
    
            List<String> nameList= list1.stream().map(User::getName).collect(Collectors.toList());
    
            
            // 交集
            List<User> intersection = list1.stream().filter(item -> list2.contains(item.getName())).collect(Collectors.toList());
            System.out.println("---得到交集 intersection---");
            //intersection.parallelStream().forEach(System.out::println);
            for (User user: intersection) {
                System.out.println(user.getName());
            }
    
            // 差集 (list1 - list2)
            List<User> reduceUser1=list1.stream().filter(user -> !list2.contains(user.getName())).collect(Collectors.toList());
            System.out.println("---得到差集 reduce1 (list1 - list2)---");
            for (User user: reduceUser1) {
                System.out.println(user.getName());
            }
            //reduceUser1.parallelStream().forEach(System.out::println);
    
            // 差集 (list2 - list1)
            list1.stream().map(user -> user.getName()).collect(Collectors.toList());
            List<String> reduce2 = list2.stream().filter(item -> !nameList.contains(item)).collect(Collectors.toList());
            System.out.println("---得到差集 reduce2 (list2 - list1)---");
            reduce2.parallelStream().forEach(System.out::println);
        }
    

    3 两个相同类型List 交、并、差集

    /**
         * 对象类型的处理
         */
        public static void showObjectDeal() {
            List<User> list1 = new ArrayList<>();
            list1.add(new User("name1",11));        list1.add(new User("name2",22));        list1.add(new User("name3",33));
            List<User> list2 = new ArrayList<>();
            list2.add(new User("name3",33));        list2.add(new User("name4",44));
            Set<User> list1Set = new HashSet<>(list1);
    
            Set<User> list2Set = new HashSet<>(list2);
    
            // 交集
            List<User> intersection = list1.stream().filter(list2Set::contains).collect(Collectors.toList());
            System.out.println("---得到交集 intersection---");
            intersection.parallelStream().forEach(System.out::println);
    
            // 差集 (list1 - list2)
            List<User> reduce1 = list1.stream().filter(item -> !list2Set.contains(item)).collect(Collectors.toList());
            System.out.println("---得到差集 reduce1 (list1 - list2)---");
            reduce1.parallelStream().forEach(System.out::println);
    
            // 差集 (list2 - list1)
            List<User> reduce2 = list2.stream().filter(item -> !list1Set.contains(item)).collect(Collectors.toList());
            System.out.println("---得到差集 reduce2 (list2 - list1)---");
            reduce2.parallelStream().forEach(System.out::println);
    
            // 并集
            List<User> listAll = list1.parallelStream().collect(Collectors.toList());
            List<User> listAll2 = list2.parallelStream().collect(Collectors.toList());
            listAll.addAll(listAll2);
            System.out.println("---得到并集 listAll---");
            listAll.parallelStream().forEach(System.out::println);
    
            // 去重并集
            list1Set.addAll(list2Set);
            List<User> listDistinctAll = new ArrayList<>(list1Set);
            System.out.println("---得到去重并集 listDistinctAll---");
            listDistinctAll.parallelStream().forEach(System.out::println);
    
            System.out.println("---原来的List1---");
            list1.parallelStream().forEach(System.out::println);
            System.out.println("---原来的List2---");
            list2.parallelStream().forEach(System.out::println);
        }
    

    4、list去重

    //List去重
    List<User> userList = list1.stream() .collect(
            Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(user -> user.getName()))), ArrayList::new));
    System.out.println("---List去重---");
    for (User user: userList) {
        System.out.println(user.getName());
    }
    
    展开全文
  • 顺序表交集并集

    2019-10-03 14:43:14
    顺序表完成交集并集 写的不是太好,有不足之处可以评论!! #include<stdio.h> #include<stdlib.h> #include<malloc.h> #define List_Size 100 //定义长度为100 typedef struct { int *elem;//...

    顺序表完成交集并集
    写的不是太好,有不足之处可以评论!!

    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    #define List_Size 100  //定义长度为100
    typedef struct {
    int *elem;//地址
    int length;//长度(实际大小)
    int listsize;//空间大小
    } Sqlist;
    //顺序表的初始化
    void InitSqList(Sqlist &L){
    L.elem=new int [List_Size];
    if(!L.elem)
    exit(1);
    L.length=0;
    L.listsize=List_Size;
    }
    //顺序表的创建(手动创建)
    void CreateSqList(Sqlist &L,int n){
    int i;
    for(i=0;i<n;i++)
    {scanf("%d",&L.elem[i]);
    L.length++;
    }
    }
    void DispSqList(Sqlist L)
    {int i;
    for(i=0;i<L.length;i++)
    printf("%d",L.elem[i]);
    printf("\n");
    }
    int main()
    {Sqlist x;
    Sqlist y;
    Sqlist z;//用来放置相同并集的元素
    int n,m;
    scanf("%d",&n);
    scanf("%d",&m);
    if((n==0&&m!=0)||(m==0&&n!=0))
    {printf("∩为空");
    if(m==0)
    {InitSqList(x);
    CreateSqList(x, n);
    DispSqList(x);
    }
    else
    InitSqList(y);
    CreateSqList(y, m);
    
    DispSqList(y);
    }
    if(m==0&&n==0)
    {printf("∩为空");
    printf("∪为空");
    }
    else
    
    InitSqList(x);
    CreateSqList(x, n);
    InitSqList(y);
    CreateSqList(y, m);
    InitSqList(z);
    int i,j;
    //求其交集
    for(i=0;i<n;i++)
    {for(j=0;j<m;j++)
    {if (x.elem[i]==y.elem[j]) 
    {z.elem[z.length]=x.elem[i];
    z.length++;
    }
    }
    }
    
    DispSqList(z);
    //求并集
    Sqlist a;//用来放置相同交集的元素
    int b=0,c=0,p;
    InitSqList(a);
    for(i=0;i<n;i++)//先来把x的数据放进去
    {a.elem[a.length]=x.elem[i];
    a.length++;
    }
    for(c=0,p=0;c<m;c++)
    {
    for(b=0;b<m+n;b++)
    {if(y.elem[c]==z.elem[b])
    {   p=0;
    	break;}
    else
    p++;
    }
    if(p==m+n)
    {a.elem[a.length]=y.elem[c];
    a.length++;
    p=0;
    }
    }
    DispSqList(a);
    
    return 0;
    }
    
    
    
    
    
    展开全文
  • 2015高中数学交集并集教学案新人教A版必修1
  • 用C#简单实现了对字符串数组求交集并集,定义类
  • java实现交集并集差集

    万次阅读 2020-03-12 20:09:14
    java实现交集并集差集 ***`package 第一次模拟测试; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Scanner; import java.util.Set; public class 集合 { public...
  • String交集 并集 差集 去重复并集https://blog.csdn.net/Hu531053/article/details/103988470 Object交集 并集 差集 去重复并集...
  • sort求交集并集差集

    2019-03-28 00:46:46
    uniq -u 取出只出现过一次的元素,用来求差集 uniq -c group by ...所以求交集并集差集的关键不是在sort, 而是在uniq后面的选项 如果单纯只有uniq, 就是单纯的去重,其实就是取并集 所以sort a b|un...
  • 采用java8 lambda表达式 实现java list 交集/并集/差集/去重并集一般的javaList 交、并集采用简单的 removeAll retainAll 等操作,不过这也破坏了原始的javaList对象,采用java8 lambda表达式流操作则可以不影响原始...
  • 两个字符串交集并集

    2011-10-31 10:55:33
    输入两个字符串,求他们的交集并集,我用的是ArrayList类,也可以用StringBuider类
  • 彩票简单工具可用来对彩票大底进行交集处理并得出交集并集和差集
  • python 数组 交集 并集 差集 1.交集 a = [1, 3, 5] b = [2, 3, 4] print(set(a).intersection(b)) #输出 {3} 2.并集 a = [1, 3, 5] b = [2, 3, 4] print(set(a).union(b)) #输出 {1, 2, 3, 4, 5} 3.差集 a = [1, 3...
  • JAVA Hashset求集合的交集并集差集 Hashset是Set接口较为常见的一个子类,该子类的最大特点是不允许保存重复的元素,并且所有的内容都采用散列(无序)的方式进行存储。 package com.company; //集合的交集并集差集...
  • java 两个list 交集 并集 差集 去重复并集 前提需要明白List是引用类型,引用类型采用引用传递。 我们经常会遇到一些需求求集合的交集、差集、并集。例如下面两个集合: 复制代码 List list1 = new ArrayList(); list...
  • java list 交集 并集 差集 去重复并集 package com; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Test {  public static void main(String[] args) { ...
  • C++ stl set 求集合的交集并集差集 编译环境为dev C++
  • 用数据结构循环链表的知识实现集合的交集并集
  • 用数据结构双向链表的只是实现了求集合的交集并集
  • 江苏省徐州市贾汪区建平中学高中数学1.3交集并集教案2苏教版必修1
  • 江苏省徐州市贾汪区建平中学高中数学1.3交集并集教案1苏教版必修1
  • C# 两个datatable中的数据快速比较返回交集 并集或差集 网上的例子。但没有实例下载。新人有点难明白。对初学者还是有点难。完整源码。让新人学习。
  • Java集合操作 交集 并集 差集 创建两个集合: //直接在创建时赋值 List<String> l2 = new ArrayList<String>(){{add("q"); add("w"); add("e"); add("s"); add("d");}}; List<String> l1 = new...
  • 之前写过一篇文章,采用java8 lambda表达式 实现 java list 交集 并集 差集 去重复并集 当时没有考虑到性能和 对一般对象的处理,这里做下日志说明一下: 原来文章 ...
  • 江苏省射阳县第二中学高中数学1.3交集并集导学案一无答案苏教版必修1

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 92,583
精华内容 37,033
关键字:

交集并集