Java 在列表中查找频率差元素

实际上我正在努力解决这个问题

请允许我添加一些描述，实际上有两个数字列表，几乎相同，但由于第一个列表中缺少一些数字，所以第二个列表中的所有数字都完好无损，但第一个列表中缺少一些数字，我们只需打印第一个列表中缺少的数字

问题陈述

艺术家Numeros有两个列表A和B，因此B是A的排列。Numeros对这些列表感到非常自豪。不幸的是，在将它们从一个展览运送到另一个展览的过程中，一些来自A的数字被遗漏了。你能找到丢失的号码吗

注释

如果某个数字在列表中出现多次，则必须确保该数字在两个列表中出现的频率相同。如果不是这样，那么它也是一个缺失的数字

您必须按升序打印所有缺失的数字

将每个缺失的数字打印一次，即使它缺失多次

B中最大值和最小值之间的差值小于或等于100

输入格式 将有四行输入：

n - the size of the first list 
This is followed by n space-separated integers that make up the first list. 
m - the size of the second list 
This is followed by m space-separated integers that make up the second list.

输出格式 按升序输出缺失的数字：-

约束条件

1≤n,m≤1000010 
1≤x≤10000,x∈B 
Xmax−Xmin<101

样本输出

204 205 206

我写了代码：-

这是：-

import java.io.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        Map<Integer, Integer> mA = new HashMap<>(n);
        int curr = 0;
        while(n--> 0){// Creating the first map having number & its frequency
            curr = scan.nextInt();
            if(mA.containsKey(curr)){
                Integer prev = mA.get(curr);
                mA.put(curr, prev + 1);
            }else{
                mA.put(curr, 1);
            }
        }

        int n1 = scan.nextInt();
        Map<Integer, Integer> mB = new HashMap<>(n1);
        while(n1--> 0){// Creating the second map having number & its frequency
            curr = scan.nextInt();
            if(mB.containsKey(curr)){
                Integer prev = mB.get(curr);
                mB.put(curr, prev + 1);
            }else{
                mB.put(curr, 1);
            }   
        }

            List<Integer> l = new ArrayList<>();

            //Problem I think is this part somewhere I am not doing it correct in this loop
            for(Map.Entry<Integer, Integer> entry : mB.entrySet()){
                Integer k = entry.getKey();
                Integer v = entry.getValue();
                if(!mA.containsKey(k)){
                   l.add(k);
                }else if(mA.get(k) != v){
                    l.add(k);
                }
            }
            Collections.sort(l);
            List<Integer> list = new ArrayList<>(new LinkedHashSet<Integer>(l));

           for(Integer i : l){
               System.out.print(i + " ");
           }
        }
}

import java.io.*；
导入java.util.*；
公共类解决方案{
公共静态void main（字符串[]args）{
/*在此处输入代码。从STDIN读取输入。将输出打印到STDOUT。您的类应命名为Solution*/
扫描仪扫描=新扫描仪（System.in）；
int n=scan.nextInt（）；
Map mA=新的HashMap（n）；
int curr=0；
当（n-->0）{//创建第一个具有数字及其频率的映射时
curr=scan.nextInt（）；
如果（货币）{
上一个整数=mA.get（当前）；
平均卖出价（当前、上一个月+1）；
}否则{
马币（1元）；
}
}
int n1=scan.nextInt（）；
Map mB=新的HashMap（n1）；
而（n1-->0）{//创建第二个具有数字及其频率的映射
curr=scan.nextInt（）；
如果（mB.containsKey（当前））{
整数prev=mB.get（curr）；
mB.put（当前、上一个+1）；
}否则{
mB.put（货币，1）；
}   
}
列表l=新的ArrayList（）；
//我想问题是这部分在这个循环中我做得不对
对于（Map.Entry:mB.entrySet（））{
整数k=entry.getKey（）；
整数v=entry.getValue（）；
如果（！mA.containsKey（k））{
l、 添加（k）；
}如果（mA.get（k）！=v）{
l、 添加（k）；
}
}
集合。排序（l）；
列表列表=新的ArrayList（新的LinkedHashSet（l））；
for（整数i:l）{
系统输出打印（i+“”）；
}
}
}

我认为问题出在for循环中，我正在比较两个映射中的条目。我认为我做得不对！！ 因为它打印的数字在两张地图中的频率计数相同。

试试这个

`

公共类Abce{
公共静态void main（字符串[]args）{
ArrayList A=新的ArrayList（）；
A.加入第（1）款；
A.加入第（1）款；
A.加入第（1）款；
A.加入（2）；
A.加入第（1）款；
ArrayList B=新的ArrayList（）；
B.添加（1）；
B.添加（1）；
B.添加（2）；
B.添加（1）；
//查找并删除
for（整数：B）{
if（A.contains（整数））{
A.删除（整数）；
}
}
//打印其余项目
for（整数：A）{
System.out.println（整数）；
}
}
}`

问题是

for(Map.Entry<Integer, Integer> entry : mB.entrySet()){
    Integer k = entry.getKey();
    Integer v = entry.getValue();
    if(!mA.containsKey(k)){
        l.add(k);
    }else if(mA.get(k).intValue() != v.intValue()){//This is the problem
        l.add(k);
    }
}

for（Map.Entry:mB.entrySet（））{
整数k=entry.getKey（）；
整数v=entry.getValue（）；
如果（！mA.containsKey（k））{
l、 添加（k）；
}否则如果（mA.get（k）.intValue（）！=v.intValue（））{//这就是问题所在
l、 添加（k）；
}
}

因为之前您比较的是两个整数对象而不是两个

int

值（对于较小的整数值，它都映射到同一个对象，但是对于较大的整数，Java在执行自动装箱时创建新对象）

这个问题实际上只需要一个映射，如果使用一个而不是HashMap，您会发现这更方便

请注意

Xmax-Xmin<101

，因此我们甚至可以使用数组

数据[101]

来存储数字，以进一步改进。

尝试使用数组：

int[] a = new int[n];
int[] b = new int[m];
// read into a and b
int[] freqs = new int[10001];

for (int i = 0; i < m; i++)
{
    freqs[b[i]]++;
}
for (int i = 0; i < n; i++)
{
    freqs[a[i]]--;
}
for (int i = 0; i <= 10000; i++)
{
    if (freqs[i] > 0) System.out.println(i + " ");
}

int[]a=新的int[n]；
int[]b=新的int[m]；
//读入a和b
int[]freqs=新int[10001]；
for（int i=0；i

void printmissing（HashMap firstset，HashMap secondset）{
Set keys=secondset.keySet（）；
用于（整数k：键）{
secondset.put（k，secondset.get（k）-firstset.get（k））；
}
用于（整数k：键）{
if（secondset.get（k）>0）
系统输出打印（“+k”）；
}

在main方法的LinkedHashMap中添加整数值，并调用上述方法以按顺序显示缺少的数字

    HashMap<Integer, Integer> firstset=new LinkedHashMap<>();
    HashMap<Integer, Integer>  secondset=new LinkedHashMap<>();

HashMap firstset=newlinkedhashmap（）；
HashMap secondset=新建LinkedHashMap（）；

您的问题是什么？您的输出不正确？是的，它打印的数字在两个地图中的频率计数相同。奇怪的是，我看不出您的代码有任何问题。您有问题的输入吗？是的，我有，我想分享，但这是一个很大的数字列表，如何将其传递给其他人？正确的输出将是我需要有频率的考虑也。在上面，如果作为一个结果，你会得到1。所以频率有b

int[] a = new int[n];
int[] b = new int[m];
// read into a and b
int[] freqs = new int[10001];

for (int i = 0; i < m; i++)
{
    freqs[b[i]]++;
}
for (int i = 0; i < n; i++)
{
    freqs[a[i]]--;
}
for (int i = 0; i <= 10000; i++)
{
    if (freqs[i] > 0) System.out.println(i + " ");
}

  void printmissing(HashMap<Integer, Integer> firstset,HashMap<Integer, Integer> secondset){
    Set<Integer> keys=secondset.keySet();
    for(Integer k:keys){
        secondset.put(k, secondset.get(k)-firstset.get(k));
    }
    for(Integer k:keys){
        if(secondset.get(k)>0)
            System.out.print(" "+k);
    }

    HashMap<Integer, Integer> firstset=new LinkedHashMap<>();
    HashMap<Integer, Integer>  secondset=new LinkedHashMap<>();