两数组用最少次数查出相同元素

最新推荐文章于 2024-09-06 10:38:06 发布
最新推荐文章于 2024-09-06 10:38:06 发布
阅读量95 收藏
点赞数
分类专栏： java 文章标签： Java 算法 J#
一 
package com;   

import java.util.ArrayList;   
import java.util.HashMap;   
import java.util.List;   
import java.util.Random;   

public class JudgeArrayContain {   

    static int[] M = new int[100];   
    static int[] N = new int[100000];   
    static HashMap m = new HashMap();   
    static int count = 0;   
    static List<Integer> result = new ArrayList<Integer>();   
    static long startDate;   
    static long endDate;   

    public static void main(String[] args) {   
        // 初始化数据   
        init();   

        // 输出M和N的长度   
        System.out.println("M的长度为=" + M.length);   
        System.out.println("N的长度为=" + N.length);   

        find(M, N);   
        // 试试哈希表   
        hash();   

        list();   

        besthash();   
        bestlist();   

    }   

    // 初始化数据   
    public static void init() {   
        for (int i = 0; i < 100; i++) {   
            M[i] = new Random().nextInt(100);   
        }   
        for (int i = 0; i < 100000; i++) {   
            N[i] = new Random().nextInt(100);   
        }   
    }   

    // 哈希算法   
    public static void hash() {   
        count = 0;   
        startDate = System.currentTimeMillis();   
        for (int i = 0; i < M.length; i++) {   
            m.put(i, M[i]);   
            count++;   
        }   
        for (int i = 0; i < N.length; i++) {   
            // 将N的数放到M哈希表的时候判断一下是否有一样的.   
            if (m.containsValue(N[i])) {   
                // System.out.println("N[" + i + "]=" + N[i]);   
            } else {   
            }   
            count++;   
        }   
        endDate = System.currentTimeMillis();   
        System.out.println("hash()循环了多少次count=" + count);   
        System.out.println("hash()执行时间：" + (endDate - startDate));   
    }   

    // best哈希算法   
    public static void besthash() {   
        count = 0;   
        if (M.length > N.length) {   
            startDate = System.currentTimeMillis();   
            for (int i = 0; i < M.length; i++) {   
                m.put(i, M[i]);   
                count++;   
            }   
            for (int i = 0; i < N.length; i++) {   
                // 将N的数放到M哈希表的时候判断一下是否有一样的.   
                if (m.containsValue(N[i])) {   
                    // System.out.println("N[" + i + "]=" + N[i]);   
                } else {   
                }   
                count++;   
            }   
            endDate = System.currentTimeMillis();   
            System.out.println("besthash()循环了多少次count=" + count);   
            System.out.println("besthash()执行时间：" + (endDate - startDate));   
        } else {   
            startDate = System.currentTimeMillis();   
            for (int i = 0; i < N.length; i++) {   
                m.put(i, N[i]);   
                count++;   
            }   
            for (int i = 0; i < M.length; i++) {   
                // 将N的数放到M哈希表的时候判断一下是否有一样的.   
                if (m.containsValue(M[i])) {   
                    // System.out.println("M[" + i + "]=" + M[i]);   
                } else {   
                }   
                count++;   
            }   
            endDate = System.currentTimeMillis();   
            System.out.println("besthash()循环了多少次count=" + count);   
            System.out.println("besthash()执行时间：" + (endDate - startDate));   
        }   
    }   

    // List算法   
    public static void list() {   
        count = 0;   
        startDate = System.currentTimeMillis();   
        for (int i = 0; i < M.length; i++) {   
            result.add(M[i]);   
            count++;   
        }   
        for (int i = 0; i < N.length; i++) {   
            // 将N的数放到M哈希表的时候判断一下是否有一样的.   
            if (result.contains(N[i])) {   
                // System.out.println("N[" + i + "]=" + N[i]);   
            } else {   
            }   
            count++;   
        }   
        endDate = System.currentTimeMillis();   
        System.out.println("list()循环了多少次count=" + count);   
        System.out.println("list()执行时间：" + (endDate - startDate));   
    }   

    // best哈希算法   
    public static void bestlist() {   
        count = 0;   
        if (M.length > N.length) {   
            startDate = System.currentTimeMillis();   
            for (int i = 0; i < M.length; i++) {   
                result.add(M[i]);   
                count++;   
            }   
            for (int i = 0; i < N.length; i++) {   
                // 将N的数放到M哈希表的时候判断一下是否有一样的.   
                if (result.contains(N[i])) {   
                    // System.out.println("N[" + i + "]=" + N[i]);   
                } else {   
                }   
                count++;   
            }   
            endDate = System.currentTimeMillis();   
            System.out.println("list()循环了多少次count=" + count);   
            System.out.println("list()执行时间：" + (endDate - startDate));   
        } else {   
            startDate = System.currentTimeMillis();   
            for (int i = 0; i < N.length; i++) {   
                result.add(N[i]);   
                count++;   
            }   
            for (int i = 0; i < M.length; i++) {   
                // 将N的数放到M哈希表的时候判断一下是否有一样的.   
                if (result.contains(M[i])) {   
                    // System.out.println("M[" + i + "]=" + M[i]);   
                } else {   
                }   
                count++;   
            }   
            endDate = System.currentTimeMillis();   
            System.out.println("bestlist()循环了多少次count=" + count);   
            System.out.println("bestlist()执行时间：" + (endDate - startDate));   
        }   
    }   

    // 先用最笨的方法   
    public static void find(int[] a, int[] b) {   
        count = 0;   
        startDate = System.currentTimeMillis();   
        for (int i = 0; i < M.length; i++) {   
            for (int j = 0; j < N.length; j++) {   
                if (M[i] == N[j]) {   
                    // System.out.println(M[i]);   
                    // break ;   
                }   
                count++;   
            }   
        }   
        endDate = System.currentTimeMillis();   
        System.out.println("find()循环了多少次count=" + count);   
        System.out.println("执行时间：" + (endDate - startDate));   

    }   
}


来自http://www.iteye.com/problems/24897
二两集合差的常用用法
1 
import java.util.ArrayList;   
import java.util.List;   

/**   
 * 利用双重循环实现的筛选  
 */  
public class DoubleCycling{   
    public static void main(String[] args){   
        String[] arr01={"Andy","Bill","Cindy","Douglas","Felex","Green"};   
        String[] arr02={"Andy","Bill","Felex","Green","Gates"};   

        // 筛选过程，注意其中异常的用途   
        List<String> ls=new ArrayList<String>();   
        for(String str:arr01){   
            try{   
                ls.add(getNotExistStr(str,arr02));   
            }   
            catch(Exception ex){   
                continue;   
            }               
        }   

        // 取得结果   
        Object[] arr03=ls.toArray();   
        for(Object str:arr03){   
            System.out.println(str);   
        }   
    }   

    /**   
     * 查找数组Arr中是否包含str，若包含抛出异常，否则将str返回  
     * @param str  
     * @param arr  
     * @return  
     * @throws Exception  
     */  
    public static String getNotExistStr(String str,String[] arr) throws Exception{   
        for(String temp:arr){   
            if(temp.equals(str)){   
                throw new Exception("");   
            }   
        }   

        return str;   
    }   
}

2速度较高的解法-利用哈希表 

import java.util.ArrayList;   
import java.util.Collection;   
import java.util.Hashtable;   
import java.util.List;   
import java.util.Map;   

/**   
 * 利用哈希表进行筛选  
 */  
public class HashtableFilter{   
    public static void main(String[] args){   
        String[] arr01={"Andy","Bill","Cindy","Douglas","Felex","Green"};   
        String[] arr02={"Andy","Bill","Felex","Green","Gates"};   


        Map<String,String> ht=new Hashtable<String,String>();   

        // 將arr02所有元素放入ht   
        for(String str:arr02){   
            ht.put(str, str);   
        }   

        // 取得在ht中不存在的arr01中的元素   
        List<String> ls=new ArrayList<String>();   
        for(String str:arr01){   
            if(ht.containsKey(str)==false){   
                ls.add(str);   
            }   
        }   

        // 取得结果   
        Object[] arr03=ls.toArray();   
        for(Object str:arr03){   
            System.out.println(str);   
        }   
    }   
}

3最方便的解法-利用工具类 


import java.util.ArrayList;   
import java.util.List;   

/**   
 * 使用工具类的筛选去除  
 */  
public class Tool{   
    public static void main(String[] args){   
        String[] arr01={"Andy","Bill","Cindy","Douglas","Felex","Green"};   
        String[] arr02={"Andy","Bill","Felex","Green","Gates"};   

        // 直接转的话，生成的List不支持removeAll   
        List<String> ls01=new ArrayList<String>();   
        for(String str:arr01){   
            ls01.add(str);   
        }   

        // 同上   
        List<String> ls02=new ArrayList<String>();   
        for(String str:arr02){   
            ls02.add(str);   
        }   

        // 去除arr01中存在于arr02中的元素   
        ls01.removeAll(ls02);   

        // 取得结果   
        Object[] arr03=ls01.toArray();   
        for(Object str:arr03){   
            System.out.println(str);   
        }   
    }   
}

4利用二叉树的解法 

import java.util.ArrayList;   
import java.util.List;   

/**   
 * 使用二叉樹的筛选去除  
 */  
public class Test{   
    public static void main(String[] args){   
        String[] arr01={"Andy","Bill","Cindy","Douglas","Felex","Green"};   
        String[] arr02={"Andy","Bill","Felex","Green","Gates"};   

        // 以數組2為基礎創建二叉樹   
        Tree tree=new Tree();           
        for(String str:arr02){   
            tree.insert(str);   
        }   

        // 將在二叉樹中不存在的元素放入鏈錶   
        List<String> ls=new ArrayList<String>();           
        for(String str:arr01){   
            if(tree.find(str)==null){   
                ls.add(str);   
            }   
        }   

        // 輸出   
        for(String str:ls){   
            System.out.println(str);   
        }   
    }   
}


5
Set s = new HashSet(arr01);
s.removeAll(arr02);
来自http://www.iteye.com/problems/19116
daixj110
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
找出具有n个元素的集合中最大的两个元素，要求比较次数尽可能少（三种算法的思考）
Will_Lee_Buaa的专栏
10-20 7270
题目：给定具有n个元素的集合，找出最大的两个元素，算法要求比较次数尽可能少 这个题目要做出来很简单，但是要找出比较次数尽可能少的算法也不是件容易的事情。 对于这个题目，目前有三种方法比较流行。 第一种：对集合扫描两遍（当然也可以扫描一遍，同时最大和第二大元素，但花费的比较次数和扫描两遍，在最坏情况下是一样的），第一遍找出最大的元素，第二遍从剩余的元素中找出最大的元素，即整个集合的第二
Leecode 题集
lena blog
02-21 1158
题目 给定一个二进制数组， 计算其中最大连续 1 的个数。 解答： class Solution { public int findMaxConsecutiveOnes(int[] nums) { int sum=0; for(int i=0;i<nums.length;i++){ if(nums[i]==1){ sum++; }else{ if(
如何找出两个数组中相同的元素？
niuniu_mango的博客
10-29 7578
```javascript let arr1 = [1,5,8,9], arr2 = [4,5,1,2]; let findSame = function(arr1,arr2){ let newArr = [], sortArr1 = arr1.sort(), sortArr2 = arr2.sort(); let i = 0, j = 0; while ( i < a.
比较两个数组中的所有元素是否相等的最简单方法（时间复杂度最低）,只需三次循环
kanlon的博客
09-28 1万+
比较两个数组中的所有元素是否相等的最简单方法（时间复杂度最低）,只需三次循环题目思路1思路2Java代码实现 题目 这里有两个数组，要比较他们全部元素是否相等，例如有两个数组{1,2,46} ,{2,46,1} 这样的数组他们含有相同元素，所以相等。而{2,4}，{4,5} 这样的两个数组则不相等。 思路1   直接对两个数组进行排序，然后在进行遍历逐个比较，这样是一个方法，好处是不用占用别的空...
查找数组里相同元素的个数
weixin_33881050的博客
04-20 1005
求一个数组里各个元素的出现次数。解决的方法有很多，下面自己写了2个： //找出数组中各元素出现的次数 int[] list = new int[] { 1, 1, 2, 3, 1, 2, 4, 3, 3, 2, 4, 5, 6, 5, 6, 7, 3, 2, 8 }; Console.Write("原数组："); ...
算法：一次循环找出数组中出现次数最少的数字
Comvir的专栏
09-07 1506
题目:一次循环找出数组中出现次数最少的数字。 本题使用JS实现
LeetCode刷题——数组中数字出现次数
林慢慢的博客
07-10 1355
文章目录前言：刷题前先提一下类似Leetcode和牛客网这类在线OJ的两种类型：接口型和IO型。正文：1.只出现一次的数字思路实现：2.数组中数字出现的次数2.1 找出两个只出现一次的数（其余数字均出现两次）思路实现：2.2 找出一个只出现一次的数（其余数字均出现三次）思路实现：3.消失的数字思路二实现(0~n计算等差数列和-数组中所有值相加)思路三实现(异或) 前言： 刷题前先提一下类似Leetcode和牛客网这类在线OJ的两种类型：接口型和IO型。 接口型：测试用例和结果一般是通过参数接口函数的参数和
php查找数组中最小的数据,PHP程序查找数组中的最小元素
weixin_42520239的博客
03-13 593
为了找到数组中的最小元素，PHP代码如下-示例
刷题笔记
热门推荐
weixin_30606461的博客
08-10 2万+
基本排序算法 基于比较的排序 冒泡排序 没什么可说的, 改进方法就是加一个标志位防止有序后重复遍历. 由于需要遍历两次, 所以时间复杂度O(N^2) 传送门 --> 冒泡排序 选择排序 外层从0开始默认outer是最小数的下标, 内存从outer+1位置开始遍历, 不稳定, 如{ 3, 3, 3, 2 }, 当比较最后一个4时, 是第一个3和2交换, 从而不稳定. 内外层遍历两...
IC面试经验
qq_40800500的博客
02-20 2104
乐鑫 IC设计 IC验证 常见问题 设计 技术面试，根据项目来，会让你画系统框图，具体的性能指标 1、建立时间、保持时间、亚稳态的出现与消除、传染性 建立时间：触发器的时钟上升沿到来前，数据保持不变的时间 保持时间：触发器的时钟上升沿到来后，数据保持不变的时间 触发器的建立时间和保持时间在时钟沿上定义了一个窗口，如果触发器数据输入端口上的数据在这个窗口内发生变化，那么就产生了时序违例。此时触发器的晶体管不能可靠地设置为逻辑0或逻辑1，就是亚稳态。 触发器输出保持亚稳态的时间是随机的，打两拍不一定能解决亚
mysql map结构_Map的常用所有实现类数据结构简单解析
weixin_30336949的博客
02-04 1330
一、Map集合框架HashTable线程安全。Properties是配置文件读取使用。HashMap基于散列表的实现，插入和查询的键值对的开销是固定的，LindkedHashMap类似于HashMap，插入时有次序，插入时略慢，但是基于链表的遍历叫较快。TreeMap基于红黑树的实现，他们会被排序，它是唯一带有subMap方法的Map，它可以返回一个子树。ConcurrentHashMap一种线程...
java面试题
m0_52071544的博客
11-25 1052
常识: 1.如果数据相同,问: hash值是否相同? 是相同的. 2.问 一个数据10K,一个数据1G 问 运算速度如何? 一样快(约等于) springboot启动过程 1.在main函数所在的类上加@SpringBootApplication是一个主启动类 2.主启动类中包含四种注解,其作用为: (1)元注解说明 说明: 修饰注解的注解称之为元注解 @Target(ElementType.TYPE) 该注解对类有效 @Retention(RetentionPolicy.RUNTIME) 表示运行期有效
SQL常见雷区，函数，优化，执行顺序，使用技巧汇总
修行的博客
05-26 1371
SQL常见雷区，函数，优化，执行顺序，使用技巧汇总 一、sql使用技巧 1、去重统计 select count(distinct 去重字段) from 表 2、字段别名和 group by 踩这个坑还是很难受的，亏得公司的学长看出来了，希望下次不要再入坑了。 sql1: select d.cellid,d.num from( select z.cellid,avg(z.rsrp) as num from data_zlwc z where z.ce
找出数组中重复元素，并按重复的次数由少到多排序 es6
ringlot的博客
05-18 1113
最近在面试的时候出现的一个考题，当时做出来了，回来验证后发现有点小问题，现在把这个记录下来供自己以后参考。自己写的，用的es6的写法。 repeat(arr) { let e = [] arr.forEach(item => { let num = arr.filter(n => n === item).length if (
代码随想录算法训练营day30
qq_56445436的博客
09-05 446
【代码】代码随想录算法训练营day30。
树状数组记录
最新发布
volcan的博客
09-06 677
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 395
力扣刷题--1534. 统计好三元组【简单】
用数组写一个删除相同元素的函数
08-16
要写一个删除数组中相同元素的函数，我们可以使用两个循环遍历数组中的元素。首先，我们从数组的第一个元素开始，逐个与后面的元素进行比较。如果发现有相同的元素，就将该元素从数组中删除。然后，增加一个计数器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值