算法刷题-哈希表-两个数组的交集

news2024/11/16 6:29:31

两个数组的交集

    • 349. 两个数组的交集
    • 思路
    • 拓展
    • 后记
    • 其他语言版本
    • 相关题目

如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费！

349. 两个数组的交集

力扣题目链接

题意：给定两个数组，编写一个函数来计算它们的交集。

349. 两个数组的交集

说明：
输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。

思路

这道题目，主要要学会使用一种哈希数据结构：unordered_set，这个数据结构可以解决很多类似的问题。

注意题目特意说明：输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的， 同时可以不考虑输出结果的顺序

这道题用暴力的解法时间复杂度是O(n^2)，那来看看使用哈希法进一步优化。

那么用数组来做哈希表也是不错的选择，例如242. 有效的字母异位词

但是要注意，使用数组来做哈希的题目，是因为题目都限制了数值的大小。

而这道题目没有限制数值的大小，就无法使用数组来做哈希表了。

而且如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。

此时就要使用另一种结构体了，set ，关于set，C++ 给提供了如下三种可用的数据结构：

  • std::set
  • std::multiset
  • std::unordered_set

std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表， 使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。

思路如图所示：

set哈希法

C++代码如下：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        for (int num : nums2) {
            // 发现nums2的元素 在nums_set里又出现过
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

拓展

那有同学可能问了，遇到哈希问题我直接都用set不就得了，用什么数组啊。

直接使用set 不仅占用空间比数组大，而且速度要比数组慢，set把数值映射到key上都要做hash计算的。

不要小瞧 这个耗时，在数据量大的情况，差距是很明显的。

后记

本题后面 力扣改了 题目描述 和 后台测试数据，增添了 数值范围：

  • 1 <= nums1.length, nums2.length <= 1000
  • 0 <= nums1[i], nums2[i] <= 1000

所以就可以 使用数组来做哈希表了， 因为数组都是 1000以内的。

对应C++代码如下：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        int hash[1005] = {0}; // 默认数值为0
        for (int num : nums1) { // nums1中出现的字母在hash数组中做记录
            hash[num] = 1;
        }
        for (int num : nums2) { // nums2中出现话，result记录
            if (hash[num] == 1) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

其他语言版本

Java：

import java.util.HashSet;
import java.util.Set;

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
            return new int[0];
        }
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> resSet = new HashSet<>();
        //遍历数组1
        for (int i : nums1) {
            set1.add(i);
        }
        //遍历数组2的过程中判断哈希表中是否存在该元素
        for (int i : nums2) {
            if (set1.contains(i)) {
                resSet.add(i);
            }
        }
      
        //方法1：将结果集合转为数组

        return resSet.stream().mapToInt(x -> x).toArray();
        
        //方法2：另外申请一个数组存放setRes中的元素,最后返回数组
        int[] arr = new int[resSet.size()];
        int j = 0;
        for(int i : resSet){
            arr[j++] = i;
        }
        
        return arr;
    }
}

Python3：

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        val_dict = {}
        ans = []
        for num in nums1:
            val_dict[num] = 1

        for num in nums2:
            if num in val_dict.keys() and val_dict[num] == 1:
                ans.append(num)
                val_dict[num] = 0
        
        return ans

Go：

func intersection(nums1 []int, nums2 []int) []int {
    set:=make(map[int]struct{},0)  // 用map模拟set
    res:=make([]int,0)
    for _,v:=range nums1{
        if _,ok:=set[v];!ok{
            set[v]=struct{}{}
        }
    }
    for _,v:=range nums2{
        //如果存在于上一个数组中，则加入结果集，并清空该set值
        if _,ok:=set[v];ok{
            res=append(res,v)
            delete(set, v)
        }
    }
    return res
}

javaScript:

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersection = function(nums1, nums2) {
    // 根据数组大小交换操作的数组
    if(nums1.length < nums2.length) {
        const _ = nums1;
        nums1 = nums2;
        nums2 = _;
    }
    const nums1Set = new Set(nums1);
    const resSet = new Set();
    // for(const n of nums2) {
    //     nums1Set.has(n) && resSet.add(n);
    // }
    // 循环 比 迭代器快
    for(let i = nums2.length - 1; i >= 0; i--) {
        nums1Set.has(nums2[i]) && resSet.add(nums2[i]);
    }
    return Array.from(resSet);
};

TypeScript:

版本一（正常解法）：

function intersection(nums1: number[], nums2: number[]): number[] {
    let resSet: Set<number> = new Set(),
        nums1Set: Set<number> = new Set(nums1);
    for (let i of nums2) {
        if (nums1Set.has(i)) {
            resSet.add(i);
        }
    }
    return Array.from(resSet);
};

版本二（秀操作）：

function intersection(nums1: number[], nums2: number[]): number[] {
    return Array.from(new Set(nums1.filter(i => nums2.includes(i))))
};

Swift：

func intersection(_ nums1: [Int], _ nums2: [Int]) -> [Int] {
    var set1 = Set<Int>()
    var set2 = Set<Int>()
    for num in nums1 {
        set1.insert(num)
    }
    for num in nums2 {
        if set1.contains(num) {
            set2.insert(num)
        }
    }
    return Array(set2)
}

PHP:

class Solution {
    /**
     * @param Integer[] $nums1
     * @param Integer[] $nums2
     * @return Integer[]
     */
    function intersection($nums1, $nums2) {
        if (count($nums1) == 0 || count($nums2) == 0) {
            return [];
        }
        $counts = [];
        $res = [];
        foreach ($nums1 as $num) {
            $counts[$num] = 1;
        }
        foreach ($nums2 as $num) {
            if (isset($counts[$num])) {
                $res[] = $num;
            }
            unset($counts[$num]);
        }
        
        return $res;
    }
}

Rust:

use std::collections::HashSet;
impl Solution {
    pub fn intersection(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
        let mut resultSet: HashSet<i32> = HashSet::with_capacity(1000);
        let nums1Set: HashSet<i32> = nums1.into_iter().collect();
        
        for num in nums2.iter() {
            if nums1Set.contains(num) {
                resultSet.insert(*num);
            }          
        }
        
        let ret: Vec<i32> = resultSet.into_iter().collect();
        ret
    }
}

解法2:

use std::collections::HashSet;
impl Solution {
    pub fn intersection(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
        nums1
            .into_iter()
            .collect::<HashSet<_>>()
            .intersection(&nums2.into_iter().collect::<HashSet<_>>())
            .copied()
            .collect()
    }
}

C:

int* intersection1(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){

    int nums1Cnt[1000] = {0};
    int lessSize = nums1Size < nums2Size ? nums1Size : nums2Size;
    int * result = (int *) calloc(lessSize, sizeof(int));
    int resultIndex = 0;
    int* tempNums;
    
    int i;

    /* Calculate the number's counts for nums1 array */
    for(i = 0; i < nums1Size; i ++) {
        nums1Cnt[nums1[i]]++;
    }

    /* Check if the value in nums2 is existing in nums1 count array */
    for(i = 0; i < nums2Size; i ++) {
        if(nums1Cnt[nums2[i]] > 0) {
            result[resultIndex] = nums2[i];
            resultIndex ++;
            /* Clear this count to avoid duplicated value */
            nums1Cnt[nums2[i]] = 0;
        }
    }
    * returnSize = resultIndex;
    return result;
}

Scala:

正常解法:

object Solution {
  def intersection(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
    // 导入mutable
    import scala.collection.mutable
    // 临时Set，用于记录数组1出现的每个元素
    val tmpSet: mutable.HashSet[Int] = new mutable.HashSet[Int]()
    // 结果Set，存储最终结果
    val resSet: mutable.HashSet[Int] = new mutable.HashSet[Int]()
    // 遍历nums1，把每个元素添加到tmpSet
    nums1.foreach(tmpSet.add(_))
    // 遍历nums2，如果在tmpSet存在就添加到resSet
    nums2.foreach(elem => {
      if (tmpSet.contains(elem)) {
        resSet.add(elem)
      }
    })
    // 将结果转换为Array返回，return可以省略
    resSet.toArray
  }
}

骚操作1:

object Solution {
  def intersection(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
    // 先转为Set，然后取交集，最后转换为Array
    (nums1.toSet).intersect(nums2.toSet).toArray
  }
}

骚操作2:

object Solution {
  def intersection(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
    // distinct去重，然后取交集
    (nums1.distinct).intersect(nums2.distinct)
  }
}

C#:

 public int[] Intersection(int[] nums1, int[] nums2) {
    if(nums1==null||nums1.Length==0||nums2==null||nums1.Length==0)
    	return new int[0]; //注意数组条件
    HashSet<int> one = Insert(nums1);
    HashSet<int> two = Insert(nums2);
    one.IntersectWith(two);
    return one.ToArray();
	}
 public HashSet<int> Insert(int[] nums){
    HashSet<int> one = new HashSet<int>();
    foreach(int num in nums){
    	one.Add(num);         
    	}
        return one;
	}

相关题目

  • 350.两个数组的交集 II

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/634971.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Java集合框架：ArrayList详解

Java集合框架：ArrayList详解

目录 一、ArrayList简介 二、ArrayList源码介绍&#xff08;动态扩容以及构造方法是如何实现的&#xff09; 1. 扩容机制&#xff1a; 源码&#xff1a; 源码详解&#xff1a; ​编辑 如何扩容&#xff1a; 2. 扩容源码详解&#xff1a; 三、ArrayList的构造方法 四、ArrayL…
阅读更多...
【Linux运维】GitLab本地服务器搭建

【Linux运维】GitLab本地服务器搭建

&#x1f60f;★,:.☆(&#xffe3;▽&#xffe3;)/$:.★ &#x1f60f; 这篇文章主要介绍gitlab本地服务器的搭建。 学其所用&#xff0c;用其所学。——梁启超 欢迎来到我的博客&#xff0c;一起学习知识&#xff0c;共同进步。 喜欢的朋友可以关注一下&#xff0c;下次更新…
阅读更多...
【JVM内存模型】—— 每天一点小知识

【JVM内存模型】—— 每天一点小知识

&#x1f4a7; J V M 内存模型 \color{#FF1493}{JVM内存模型} JVM内存模型&#x1f4a7; &#x1f337; 仰望天空&#xff0c;妳我亦是行人.✨ &#x1f984; 个人主页——微风撞见云的博客&#x1f390; &#x1f433; 《数据结构与算法》专栏的文章图文并茂&#x…
阅读更多...
MyBatis-plus(2)

MyBatis-plus(2)

实现逻辑查询: 1)and:其实如果只是想实现and查询&#xff0c;只是需要连续调用对应的方法或者是通过wrapper对象实现两次调用即可 2)and的嵌套:假设现在有这样一条语句 select * from user where username"张三" and (age>26 or userID <19)&#xff0c;这条SQ…
阅读更多...
使用django的APP在前端上传excel通过post传给后端读取并打印

使用django的APP在前端上传excel通过post传给后端读取并打印

文章目录 前言前端后端 前言 备研了&#xff0c;博客许久未更了&#xff0c;但是学期末的大作业&#xff0c;遇到了问题并成功解决了&#xff0c;不得不记录一下。 前端 <form method"post" enctype"multipart/form-data" action"/insurance/up…
阅读更多...
Hazel游戏引擎（011）窗口抽象和GLFW创建窗口

Hazel游戏引擎（011）窗口抽象和GLFW创建窗口

文中若有代码、术语等错误&#xff0c;欢迎指正 文章目录 前言步骤GIT添加GLFW子模块及编译Window类其它修改 效果Bug记录 前言 此节目的 为了有窗口效果&#xff0c;但不想使用原生的window32写起&#xff0c;所以用glfw窗口库。 也为了完成008计划事件系统的创建窗口部分 图…
阅读更多...
AI数据标注工具Doccano

AI数据标注工具Doccano

Doccano是一款开源的标注工具&#xff0c;用于自然语言处理和机器学习任务。它提供了用户友好的界面&#xff0c;使用户能够轻松地标注文本、序列标注、文本分类和文本配对等任务。doccano支持多种标注格式&#xff0c;并且可以方便地与其他机器学习工具集成。它的简单性和灵活…
阅读更多...
基于 MySQL 事务、隔离级别及 MVCC 机制详细剖析

基于 MySQL 事务、隔离级别及 MVCC 机制详细剖析

前言事务特性事务并发引发的问题脏读不可重复读幻读 隔离级别如何更改事务隔离级别 事务基本操作MVCC版本链ReadViewREAD COMMITTED脏读问题不可重复读问题 REPEATABLE READ不可重复读问题幻读问题 小结 总结 前言 MySQL 事务是比较重要且核心的一部分&#xff0c;在操作数据库…
阅读更多...
碳排放预测模型 | Python实现基于Prophet网络的碳排放预测模型（预测未来发展趋势）

碳排放预测模型 | Python实现基于Prophet网络的碳排放预测模型（预测未来发展趋势）

文章目录 效果一览文章概述研究内容环境准备源码设计学习总结参考资料效果一览 文章概述 碳排放预测模型 | Python实现基于Prophet网络的碳排放预测模型（预测未来发展趋势） 研究内容 这是数据集的链接：https://github.com/owid/co2-data/blob/master/owid-co2-data.csv 使用…
阅读更多...
读书：《指数型组织》

读书：《指数型组织》

《指数型组织》是Salim Ismail在2015年发表的一本著作&#xff0c;它探讨了在今天这个信息时代&#xff0c;一些组织为何能够在极短的时间内取得显著的成绩。他发现这些成功的组织都有一些共享的属性&#xff0c;这些属性使得他们能够比传统组织更快、更有效地扩展业务。他把这…
阅读更多...
LiangGaRy-学习笔记-Day21

LiangGaRy-学习笔记-Day21

1、LVM介绍 1.1、LVM是什么 对于生产环境下的服务器来说&#xff0c;如果存储数据的分区磁盘空间不足&#xff0c;应该如何处理&#xff1f; 添加一块硬盘–>可以满足需要再添加一块硬盘也可以满足需求&#xff1b;问题就是拷贝的速度慢&#xff1b; 这里就引入一个技术…
阅读更多...
Kubernetes小感

Kubernetes小感

从容器到容器云&#xff0c;谈谈 Kubernetes 的本质&#xff1a; 一个“容器”&#xff0c;实际上是一个由 Linux Namespace、Linux Cgroups 和 rootfs 三种技术构建出来的进程的隔离环境。 作为一名开发者&#xff0c;我并不关心容器运行时的差异。因为&#xff0c;在整个“…
阅读更多...
【深入浅出Docker原理及实战】「原理实战体系」零基础+全方位带你学习探索Docker容器开发实战指南（核心组件说明）

【深入浅出Docker原理及实战】「原理实战体系」零基础+全方位带你学习探索Docker容器开发实战指南（核心组件说明）

零基础全方位带你学习探索Docker容器开发实战指南&#xff08;核心组件说明&#xff09; 核心组件镜像定义概念与容器的关联文件系统root文件系统 bootfs启动文件系统分层存储分层覆盖处理模式镜像的写时复制机制 容器容器进程隔离性容器进程隔离性容器存储层数据卷绑定镜像和容…
阅读更多...
Spring6-01

Spring6-01

Spring6启示录 OCP开闭原则 什么是开闭原则&#xff1f; 在软件开发过程中应当对扩展开放&#xff0c;对修改关闭。也就是说如果在进行功能扩展的时候&#xff0c;添加额外的类是没有问题的&#xff0c;但因为功能扩展而修改之前运行正常的程序&#xff0c;这是不被允许的。因…
阅读更多...
Elasticsearch：二进制数据类型 - binary field

Elasticsearch：二进制数据类型 - binary field

二进制&#xff08;binary&#xff09;类型接受二进制值作为 Base64 编码字符串。 该字段默认不存储且不可搜索。Base64 编码的二进制值不得嵌入换行符 \n。 这听起来像是&#xff0c;将二进制对象存储在 Elasticsearch 中的单个字段中 PUT my-index-000001 {"mappings&…
阅读更多...
Jupyter Notebook 插件和其他小技巧

Jupyter Notebook 插件和其他小技巧

好用的插件 安装插件代码自动补全变量查看高亮代码折叠显示行号执行时间多行打印规范化代码模块快速获取jupyter notebook中安装包快捷键 安装插件 1.pip直接安装 pip install jupyter_contrib_nbextensions jupyter contrib nbextension install --user2.方法1不成功就用ano…
阅读更多...
STM32踩坑：UCOSIII下串口中断服务中使用OSIntEnter函数使程序卡死解决方案

STM32踩坑：UCOSIII下串口中断服务中使用OSIntEnter函数使程序卡死解决方案

UCOSIII下串口中断服务中使用OSIntEnter函数使程序卡死解决方案 本文侧重于 STM32 标准库&#xff0c;HAL 库可以借鉴&#xff0c;因为该项目是基于标准库做的&#xff08;因为涉及到保密&#xff0c;这里我就张贴源码进行描述了&#xff09;。 因项目需求&#xff0c;需要使用…
阅读更多...
广域网技术——ppp，pppoe

广域网技术——ppp，pppoe

目录 PPP协议概述 PPP协议原理 PPP协议三大组件&#xff1a; PPP链路建立流程 PPP连接建立接口状态&#xff1a; LCP协议报文格式 PPP协议报文格式&#xff1a; 1&#xff0c;链路层建立连接过程 LCP协商过程-正常协商 LCP协商-参数不一致 LCP协商-参数不识别 2&#xf…
阅读更多...
JVM调优工具及其相关配置

JVM调优工具及其相关配置

1.查看JVM配置及其应用使用情况 1.1在启动应用中进行测试 1jsp命令的使用 1.jsp查看当前启动的程序 2.查看相关堆中对象的使用情况 jmap -histo 16700>./log.txtnum&#xff1a;序号instances&#xff1a;实例数量bytes&#xff1a;占用空间大小class name&#xff1a;类…
阅读更多...
记录 | 将Word生成的静态网页部署到Github Page

记录 | 将Word生成的静态网页部署到Github Page

任务描述 使用Word, 可以直接获得 一个静态的网页XXX.html和对应的文件夹XXX.files问题&#xff1a;如何将它托管在github上&#xff1f; 步骤 使用github pages进行托管和发布 步骤1&#xff1a;创建仓库 创建一个新的GitHub仓库&#xff1a;访问 https://github.com 并使用…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023