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

    2020-03-27 09:31:37
    求两个数组并集。 使用union()方法来计算两个数组并集。 完整代码 import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class Main { public static void main(String[] ...

    求两个数组的并集。

    使用union()方法来计算两个数组的并集。

    完整代码

    import java.util.Arrays;
    import java.util.HashSet;
    import java.util.Set;
     
     
    public class Main {
        public static void main(String[] args) throws Exception {
            String[] arr1 = { "1", "2", "3" };
            String[] arr2 = { "7", "8", "9" };
            String[] result_union = union(arr1, arr2);
            System.out.println("并集的结果如下:");
     
            for (String str : result_union) {
                System.out.println(str);
            }
        }
     
        // 求两个字符串数组的并集,利用set的元素唯一性
        public static String[] union(String[] arr1, String[] arr2) {
            Set<String> set = new HashSet<String>();
     
            for (String str : arr1) {
                set.add(str);
            }
     
            for (String str : arr2) {
                set.add(str);
            }
     
            String[] result = {  };
     
            return set.toArray(result);
        }
    }
    

    结果输出

    并集的结果如下:
    3
    2
    1
    9
    8
    7
    

    在这里插入图片描述

    展开全文
  • 这篇文章主要介绍了Python数组并集交集补集代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 并集 a = ["a", "b", "c", "d"] b = ["b", "e"] c = ["a...
  • 今天主要总结一些js数组操作并集,交集,差集的一些方式。发现这些方式在工作用经常遇到,方法有很多种。今天主要总结一下我在工作用通常使用的方式,及一些简单的实现。其实我前面很多文章中都提及了我在工作中用的...

    前言
    今天主要总结一些js数组操作并集,交集,差集的一些方式。发现这些方式在工作用经常遇到,方法有很多种。今天主要总结一下我在工作用通常使用的方式,及一些简单的实现。其实我前面很多文章中都提及了我在工作中用的一些方式。例如:我前面文章讲includes方法,时候就提到了计算交集及差集。还有之前文章去重的方式,其实去重就是取并集的一种方式嘛!

    一、new Set 方式实现

    这种方式实现起来比较简单,原理就是参考new Set可以去重的功能 ,关于去重可以点击 https://www.haorooms.com/post/qd_ghfx 第17条。

    new Set取并集
    我封装了一个函数,可以取传入所有数组的并集,函数如下:

      //并集
        function unionArray(a,b){
           let tempArray = [];
           for(let i = 0;i<arguments.length;i++){
            tempArray.push(...new Set(arguments[i]))
           }
           return [... new Set(tempArray)]
       }
    

    使用如下:

     unionArray([1,2,3,4],[3,4,5,6],[8,8,7,7,6,6,5,5,4,4,3,3]) //(8) [1, 2, 3, 4, 5, 6, 8, 7]
    

    new Set取交集
    这里也是取2个数组的交集,多的可以自己扩展

     //交集
       function intersect(a,b){
        let set1 = new Set(a),set2 = new Set(b);
          return [...new Set([...set1].filter( x => set2.has(x)))];
       }
    

    使用方式如下:

    intersect([1,2,3,4],[3,4,5,6]) //(2) [3, 4]
    

    new Set取差集
    我这里只是取2个数组的差集,多的大家可以自行扩展。

      function difference(a,b){
        let set1 = new Set(a),set2 = new Set(b);
          return [...new Set([...set1].filter(x => !set2.has(x))),...new Set([...set2].filter(x => !set1.has(x)))];
       }
    

    用法如下:

    difference([1,2,3,4],[3,4,5,6]) //(4) [1, 2, 5, 6]
    

    二、include 方式实现

    include方式我之前写过取交集和差集的方式:https://www.haorooms.com/post/es6_string_object_array

    今天简单再来列举一下吧:

    include取并集

    function unionArray(a,b){
      let tempArr = a.slice() ;
      b.forEach(v => {!tempArr.includes(v) && tempArr.push(v)})   //tempArr=[1,2,3,4]
      return tempArr
    }
    

    用法和上面一样,传2个数组就可以取其并集

    unionArray([1,2,3,4],[3,4,5,6]); //(6) [1, 2, 3, 4, 5, 6]
    

    include方式 数组a和数组b的交集:

    a.filter(v => b.includes(v))
    

    include方式 数组a和数组b的差集:

    a.concat(b).filter(v => !a.includes(v) || !b.includes(v))
    

    函数自己封装哈,一句话

    三、 es5的方式实现

    上面的方式用的是ES6,下面我们用ES5实现一下! filter可以实现简单的去重,因此,实现并集也很简单,把数组push到一起(或者连接到一起concat),去重就可以实现并集了。

    [1,3,4,5,1,2,3,3,4,8,90,3,0,5,4,0].filter(function(elem,index,Array){
       return index === Array.indexOf(elem);
    })
    

    当然也可以用indexOf的方式(注:indexOf要考虑NAN或者不考虑NAN 2种情况)

    //不考虑NAN
    var union = a.concat(b.filter(function(v) {
    return a.indexOf(v) === -1})) 
    
    //考虑可以这么写
    var aHasNaN = a.some(function(v){ return isNaN(v) })
    var bHasNaN = b.some(function(v){ return isNaN(v) })
    var union = a.concat(b.filter(function(v) {
    return a.indexOf(v) === -1 && !isNaN(v)})).concat(!aHasNaN & bHasNaN ? [NaN] : []) 
    

    交集和差集可以模仿上面include方式,把include改成indexOf

    indexOf方式 数组a和数组b的交集:
    不考虑NaN(数组中不含NaN)

     a.filter(v => b.indexOf(v)!=-1)
    

    考虑的话如下:

    var aHasNaN = a.some(function(v){ return isNaN(v) })
    var bHasNaN = b.some(function(v){ return isNaN(v) })
    a.filter(function(v){ return b.indexOf(v) > -1 }).concat(aHasNaN & bHasNaN ? [NaN] : []) 
    

    indexOf方式 数组a和数组b的差集:
    不考虑NaN(数组中不含NaN)

       a.concat(b).filter(v => a.indexOf(v) ==-1 || b.indexOf(v)==-1)
    

    考虑的话如下:

    var aHasNaN = a.some(function(v){ return isNaN(v) })
    var bHasNaN = b.some(function(v){ return isNaN(v) })
    var difference = a.filter(function(v){ return b.indexOf(v) === -1 && !isNaN(v) }).concat(b.filter(function(v){ return a.indexOf(v) === -1 && !isNaN(v) })).concat(aHasNaN ^ bHasNaN ? [NaN] : []) 
    

    四、原始方式,假如要兼容IE9及以下版本,可以考虑

    function array_remove_repeat(a) { // 去重
        var r = [];
        for(var i = 0; i < a.length; i ++) {
            var flag = true;
            var temp = a[i];
            for(var j = 0; j < r.length; j ++) {
                if(temp === r[j]) {
                    flag = false;
                    break;
                }
            }
            if(flag) {
                r.push(temp);
            }
        }
        return r;
    }
    
    function array_intersection(a, b) { // 交集
        var result = [];
        for(var i = 0; i < b.length; i ++) {
            var temp = b[i];
            for(var j = 0; j < a.length; j ++) {
                if(temp === a[j]) {
                    result.push(temp);
                    break;
                }
            }
        }
        return array_remove_repeat(result);
    }
    
    function array_union(a, b) { // 并集
        return array_remove_repeat(a.concat(b));
    }
    
    function array_difference(a, b) { // 差集 a - b
        //clone = a
        var clone = a.slice(0);
        for(var i = 0; i < b.length; i ++) {
            var temp = b[i];
            for(var j = 0; j < clone.length; j ++) {
                if(temp === clone[j]) {
                    //remove clone[j]
                    clone.splice(j,1);
                }
            }
        }
        return array_remove_repeat(clone);
    }
    

    另外写一下多维数组转为一维数组的简单方式

    var arr = [1,[2,[[3,4],5],6]];
    
    function unid(arr){
            var arr1 = (arr + '').split(',');//将数组转字符串后再以逗号分隔转为数组
            var arr2 = arr1.map(function(x){
                return Number(x);
            });
            return arr2;
    }
    console.log(unid(arr));
    

    小结
    上面方式是我平时工作中用的比较简单的方式,当然还有其他的实现方式。这里就不在列举了。上面有ES6的实现,也有ES5的实现。也有低版本浏览器的实现方式。

    就写到这里吧,欢迎交流!

    展开全文
  • 利用java 语言,实现数组并集交集补集,数组可键入。
  • Java 实例 - 数组并集

    2020-12-28 14:01:05
    以下实例演示了如何使用 union ()方法来计算两个数组并集: Main.java 文件 import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class Main { public static void main(String[] ...

    以下实例演示了如何使用 union ()方法来计算两个数组的并集:

    Main.java 文件
    import java.util.Arrays;
    import java.util.HashSet;
    import java.util.Set;

    public class Main {
    public static void main(String[] args) throws Exception {
    String[] arr1 = { “1”, “2”, “3” };
    String[] arr2 = { “4”, “5”, “6” };
    String[] result_union = union(arr1, arr2);
    System.out.println(“并集的结果如下:”);

        for (String str : result_union) {
            System.out.println(str);
        }
    }
    
    // 求两个字符串数组的并集,利用set的元素唯一性
    public static String[] union(String[] arr1, String[] arr2) {
        Set<String> set = new HashSet<String>();
    
        for (String str : arr1) {
            set.add(str);
        }
    
        for (String str : arr2) {
            set.add(str);
        }
    
        String[] result = {  };
    
        return set.toArray(result);
    }
    

    }
    以上代码运行输出结果为:

    并集的结果如下:
    3
    2
    1
    6
    5
    4

    展开全文
  • 打印出非递减数组a与b的升序并集(去除重复元素)。 不少同学考试的时候没有认真看题,写成了交集。 #include&lt;iostream&gt; #include&lt;cstdlib&gt; #include&lt;cstring&gt; #...

    【题目来自灰灰考研】

    2018华科软院

    打印出非递减数组a与b的升序并集(去除重复元素)。

    不少同学考试的时候没有认真看题,写成了交集。

    #include<iostream>
    #include<cstdlib>
    #include<cstring>
    #define MAX 0x3f3f3f3f
    using namespace std;
    
    void deleteArraySameElement(int A[], int n, int B[], int m, int C[], int &s)
    {
    	int h1, h2, pre, index;
    	pre = MAX;
    	h1 = 0;
    	h2 = 0;
    	index = 0;
    	while(h1 < n && h2 < m)
    	{
    		if(A[h1] < B[h2])
    		{
    			if(A[h1] != pre)
    			{
    				pre = A[h1++];
    				C[index++] = pre; 
    			}
    			else
    			{
    				h1++;
    			}
    		}
    		else if(A[h1] == B[h2])
    		{
    			if(A[h1] != pre)
    			{
    				pre = A[h1++];
    				C[index++] = pre; 
    				h2++;
    			}
    			else
    			{
    				h1++;
    				h2++;
    			}
    		}
    		else
    		{
    			if(B[h2] != pre)
    			{
    				pre = B[h2++];
    				C[index++] = pre; 
    			}
    			else
    			{
    				h2++;
    			}
    		}
    	}
    	while(h1 < n)
    	{
    		if(A[h1] != pre)
    		{
    			pre = A[h1++];
    			C[index++] = pre; 
    		}
    		else
    			h1++;
    	}
    	while(h2 < m)
    	{
    		if(B[h2] != pre)
    		{
    			pre = B[h2++];
    			C[index++] = pre; 
    		}
    		else
    			h2++;
    	}
    	s = index;
    } 
    
    int main()
    {
    
    	int data1[] = {1,2,4,7,8,9,10};
    	int data2[] = {2,3,4,5,11};
    	int result[100], s;
    	deleteArraySameElement(data1, 7, data2, 5, result, s);
    	for(int i = 0; i < s; i++)
    	{
    		cout<<result[i]<<" ";
    	}
    	cout<<endl;
    }

     

    展开全文
  • https://www.cnblogs.com/TTyb/p/6283539.html
  • 以下实例演示了如何使用 union ()方法来计算两个数组并集: import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class Main { public static void main(String[] args) ...
  • js代码-2.求多个数组之间的并集
  • 函数 [varargout] = union_several (varargin) % 函数 [varargout] = union_several (varargin) % varargout{1} 是联合向量% varargout{i>1} 是各种 varargin 的索引(按它们的顺序) numarr = 长度(可变参数);...
  • 以下实例演示了如何使用 union ()方法来计算两个数组并集:import java.util.Arrays;import java.util.HashSet;import java.util.Set; public class Main { public static void main(String[] args) throws ...
  • java 两个数组并集 快速和编程指南,介绍如何使用示例程序在java中获得两个未排序数组的联合。 1.概述 在本文中,您将学习如何在java中获得两个数组并集并集是两个集合或所有集合中的所有值。 我们可以使用...
  • java数组并集/交集/差集(补集)

    千次阅读 2017-09-04 20:54:27
    java数组并集/交集/差集(补集)
  • 如何利用指针特性求数组并集与交集 javascript计算数组交集,并集,网上有很多,有些书也有介绍, 很多都是写一个set类,再添加一些方法,本质上都是利用了多次循环 我在写这个的时候,也是被别人问到,才想到,有...
  • js和es6实现数组并集、交集、差集1.数组并集2.数组交集3.数组差集 1.数组并集 js方法 具体思路是 var arr1 = [1,2,3]; var arr2 = [2,3,4]; var arr3; arr3 = arr1.filter(function(num) { return arr2.indexOf...
  • //$flag 表示 相加 还是 并集 public static function add2Array($arr1,$arr2,$flag){ $size1 = count($arr1[0]); $size2 = count($arr2[0]); if($size1 == 0){ return $arr2; } ...
  • 数组并集以及promise

    2021-05-08 15:49:01
    数组并集 resolveAfter2Seconds: function(data,code) { return new Promise(function(resolve, reject) { $.getJSON(`./json`, function (res) { var data2 = res.navigations var tempKeys = []; for(var item...
  • PHP数组 并集 交集 差集PHP数组 并集 交集 差集1.并集 array_merge2.交集 array_intersect3.差集 array_diff PHP数组 并集 交集 差集 1.并集 array_merge 字符串键名相同,后面覆盖前面,数字键名会在后面追加,不...
  • 数组随机打乱、数组去重、数组并集、数组交集、指定范围随机数
  • 关于数组并集问题

    2021-01-10 16:39:29
    关于数组并集问题 (有什么不对或者更好的方案,希望给予指正,共同学习进步) 今天学习数据结构线性表示,想到了关于数组的交并集问题, 交集很好解决,利用两层循环进行比较,将相同的元素存入链表即可,(因为...
  • C++二个数组并集的实现算法C++二个数组并集的实现算完整源码(定义,实现,main函数测试) C++二个数组并集的实现算完整源码(定义,实现,main函数测试) #include <iostream> int main() { int m, n, i...
  • 前几天面试的时候,有一道笔试题是用js求数组的交集,差集和并集,因为之前没有听过这个概念,就空着了,所以今天是想要专门写篇文章来记录一下。 现有两数组a = [1, 2, 3],b = [2, 4, 5],求a,b数组并集,交集...
  • 1.这是一个面试题,让封装一个方法,方法就是求多个数组并集,我的考虑是首先遍历数组的长度最短的,然后拿这个值去别的数组去通过js中的indexof()方法判断是否存在,还准备了一个flag变量旗帜法,因为可能有好...
  • // filter includes // 最简单 arr2.filter( item => !arr.includes(item.id) ) // filter some arr2.filter( item => !arr.some((id => id =...new Set(arr).has(item.id))

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,314
精华内容 12,525
关键字:

数组并集