标签: hashmap

Python 中的哈希图和哈希表有什么区别？

我知道它们是作为字典容器实现的，但据我所知，哈希图是同步的，因此它们一次只能由一个任务/函数操作，而哈希表可以同时由多个线程操作。我很确定字典是一个哈希图，因为它允许“无”键和“无”值，那么 Python 中的哈希表是什么？

我正在尝试创建一个Cacher结构，它将计算值存储在HashMap. 该calculation方法将采用一个类型的变量T，进行计算并返回一个具有相同类型的值T。此回调的类型calculation将为Fn(T) -> T.

我发现这个值将是HashMap实现Eq和Hash特征的关键。看起来一切都应该正常，我可以毫无错误地编译我的程序。

然后我编写了一个测试来检查一切是否按预期工作：

use std::{hash::Hash, collections::HashMap};

struct Cacher<T, U>
where
    T: Fn(U) -> U,
{
    calculation: T,
    values: HashMap<U, U>,
}

impl<T, U> Cacher<T, U>
where
    T: Fn(U) -> U,
    U: Eq + Hash + Clone,
{
    fn new(calculation: T) -> Cacher<T, U> {
        return Cacher {
            calculation,
            values: HashMap::new(),
        };
    }

    fn value(&mut self, arg: U) …

我有一本字典，在 python 中我可以使用它进行迭代

data = {"one":1,"two":2,"three":3,"four":4,....."two hundred":200}

for i,j in data.items():
    print(i,j)

有什么方法可以使用同一个对象并迭代 Rust 中的键和值吗？

假设我们有两个std::collections::HashMap-s，例如HashMap<K, V1>和HashMap<K, V2>，以及一个函数Fn(V1, V2) -> R。

如何对这些哈希图执行内部联接，以便获得HashMap<K, R>它们的共享密钥？这是一个参考实现来说明我的意思：

use std::collections::HashMap;

fn main() {
    let mut map_a = HashMap::<&str, i32>::new();
    map_a.insert("foo", 1);
    map_a.insert("bar", 2);
    map_a.insert("qux", 3);
    map_a.insert("quux", 4);
    
    let mut map_b = HashMap::<&str, i32>::new();
    map_b.insert("foo", 5);
    map_b.insert("bar", 6);
    map_b.insert("quuux", 7);
    map_b.insert("quuuux", 8);
    
    // To keep it simple I'm just combining respective values into a tuple:
    let joined_map = map_a
        .into_iter()
        .filter_map(|(key, value_a)| map_b.remove(key).map(|value_b| (key, (value_a, value_b))))
        .collect::<HashMap<&str, (i32, i32)>>(); …

你好 Stack Overflow 社区，

我在使用 Java 的 HashMap 时遇到了挑战。我有两个 HashMap，map1 和 map2，其中 map1 具有 Float 类型的键，map2 具有 Integer 类型的键。现在，我需要将条目从map1复制到map2。

import java.util.Map;
import java.util.HashMap;

public class Q9 {
    public static void main(String[] args) {
        Map<Float, String> map1 = new HashMap<>();
        Map<Integer, String> map2 = new HashMap<>();

        // Adding entries to map1
        map1.put(11.1f, "black");
        map1.put(12.1f, "brown");
        map1.put(13.1f, "Grey");
        map1.put(14.1f, "blue");

        // Now, I want to copy the entries from map1 to map2 with Integer keys
        // map2.putAll(map1); // This line gives a …

#include<bits/stdc++.h>
#include<map>
using namespace std;
bool greaterThanExists(int i,std::map<int,int>&mpp)
{
    for(auto it:mpp)
    {
        if(it.first>i && it.second>0)
        {   cout<<it.first<<endl<<endl;
            it.second--;
            return true;
        }
    }
    return false;
}

int main()
{   int n;
    cin>>n;
    map<int,int>mpp;
    for(int i=0;i<n;i++)
    {
    int x;
    cin>>x;
    mpp[x]++;
    }
    int i=0;
    while(greaterThanExists(i,mpp))
    i++;
    
    // cout<<i<<endl;
    return 0;
}

问题： https: //codeforces.com/contest/1165/problem/B

在 Codeforces 的这个问题中，我试图通过 C++ 中的引用传递地图，但显然这些更改没有反映在地图中。

我不明白为什么这没有按顺序打印哈希图。分配key的时候也是这样保存的吗？肉眼看来，它似乎是随机的。这对 Rust 来说正常吗？

use std::collections::HashMap;
use rand::Rng;

fn main() {
    let mut board = HashMap::new();
    
    for n in 0..99 {
        board.insert(n,0);
    }
    // board.insert(1, 0);

    for (key,value) in &board {
        println!("{}: {}", key, value);
    }
}

输出：

21: 0
15: 0
90: 0
10: 0
52: 0
92: 0
32: 0
61: 0
91: 0
50: 0
28: 0
93: 0
64: 0
72: 0
75: 0
95: 0
98: 0
89: 0
57: 0
88: 0
9: 0
85: …

我创建了一个带有内部地图的地图作为测试，看起来外部地图将忽略其余的地图。我认为它会压倒他们。我还认为这是因为它们都是从 Map 扩展的，所以当它们不是时，它将它们视为同一个实例。

Map<Map<Integer, String>,String> maps=new HashMap<>();
maps.put(new HashMap<Integer, String>(),"HashMap");
maps.put(new TreeMap<Integer, String>(),"TreeMap");
maps.put(new LinkedHashMap<Integer, String>(),"LinkedHashMap");
maps.put(new Hashtable<Integer, String>(),"Hashtable");

将地图打印到日志将仅显示最后添加的地图：

maps: {{}=Hashtable}

我尝试了其他 Map 实现，除了 TreeMap 之外，所有实现都具有相同的行为，由于 HashMap 没有实现，它会抛出异常Comparable。

这是预期的行为吗？为什么 HashMap 会有这样的行为？

我有一张 类型的地图HashMap<String, List<Integer>>。

我想找到每个地图条目的最大值，然后找到这些最大值中的最小值。

HashMap<String, List<Integer>> values = new HashMap<>();

values.put("a", Arrays.asList(4, 8, 9, 10)); // max value is 10
values.put("b", Arrays.asList(20, 32, 1, 2)); // max value is 32
values.put("c", Arrays.asList(11, 50, 20, 6)); // max value is 50

// I need the min value out of the above maximums i.e. 10 (final answer)