Java 地图中求最小值的有效方法

我正试图在下面显示的

地图中找到具有最小值的
键

 Map<Node, Integer> freeMap = new TreeMap<>();
 Node minNode = null;
        for (Map.Entry<Node, Integer> entry : freeMap.entrySet()) {
            if (minNode == null) {
                minNode = entry.getKey();
            } else {
                if (entry.getValue() < freeMap.get(minNode)) {
                    minNode = entry.getKey();
                }
            }
        }

Map freeMap=newtreemap（）；
节点minNode=null；
对于（Map.Entry:freeMap.entrySet（））{
if（minNode==null）{
minNode=entry.getKey（）；
}否则{
if（entry.getValue（）

首先，与使用
foreach
循环相比，是否有一种直接的方法可以使用最小的
值来查找
键
。其次，您能否建议一些替代的数据结构方法，用于存储
节点
对象和关联的
整数
值，以便我可以在恒定时间O（1）中以最小值获取
条目
 O（1）分钟的数据结构
对于另一种数据结构，如何使用

您可以使用自定义类型，也可以让您的数据类型实现

从javadoc：

实现说明：此实现为enqueing和dequeing方法（offer、poll、remove（）和add）提供了O（log（n））时间；移除（对象）和包含（对象）方法的线性时间；以及检索方法（peek、元素和大小）的固定时间

O（1）Min和摊销O（1）find的数据结构

如果您想要高效的min和effectivefind，并控制对数据结构的访问（否则问题的重点是什么？），您可以通过扩展Java的HashMap来跟踪最小元素，从而实现自己的功能

您必须重写
put
、
putAll
和
remove
方法。在每种情况下，您都可以调用超级类方法（例如，
super.put（key，value）
），然后更新最小元素，该元素作为新定义类的实例成员保留

请注意，这会将删除时间增加到（O（N））（因为您必须更新最小值）。
我怀疑
整数
值在您的系统中不是唯一的

如果是这种情况，我建议您使用guava library，并使用
Integer
value作为键

TreeMultimap<Integer, Node> freeMap = new TreeMultimap<>();
Node minNode =
  freeMap.isEmpty() 
    ? null
    : freeMap.entries().iterator().next().getValue();

TreeMultimap freeMap=new TreeMultimap（）；
节点minNode=
freeMap.isEmpty（）
? 无效的
：freeMap.entries（）.iterator（）.next（）.getValue（）；
小的改进不是全部：

Map<Node, Integer> freeMap = new TreeMap<Node, Integer>();
Node minNode = freeMap.isEmpty() ? null : (Node) freeMap.entrySet().iterator().next();
for (Map.Entry<Node, Integer> entry : freeMap.entrySet()) {
    if (entry.getValue() < freeMap.get(minNode)) {
        minNode = entry.getKey();
    }
}

Map freeMap=newtreemap（）；
Node minNode=freeMap.isEmpty（）？null：（节点）freeMap.entrySet（）.iterator（）.next（）；
对于（Map.Entry:freeMap.entrySet（））{
if（entry.getValue（）

如果你的目标是提高时间复杂度，那么实际上只有一个可能的改变，从O（n logn）到O（n）：

Map freeMap=newtreemap（）；
Map.Entry minEntry=null；
对于（Map.Entry:freeMap.entrySet（））{
if（minEntry==null | | entry.getValue（）
您可以定义自己的比较器并使用Collections.min。
例如：

Comparator customComparator=新比较器（）{
@凌驾
公共整数比较（条目o1、条目o2）{
返回（int）（o1.getValue（）-o2.getValue（））；
}
@凌驾
公共布尔等于（对象obj）{
返回false；
}
};
条目minVal=Collections.min（freeMap.entrySet（），customComparator）；

希望这有帮助：）
简洁、高效、优雅的解决方案的关键在于方法和方法

第一种方法可应用于地图的
入口集
，第二种方法提供一个
比较器
，该比较器根据地图
入口
对象的值进行比较。因此，解决方案是一行，您可以直接获取条目或密钥，如本例所示：

import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;

public class KeyWithMinValue
{
    public static void main(String[] args)
    {
        Map<String, Integer> map = new LinkedHashMap<String, Integer>();

        map.put("Zero", 0);
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);
        map.put("Four", 4);

        // Obtain the entry with the minimum value:
        Entry<String, Integer> entryWithMinValue = Collections.min(
            map.entrySet(), Entry.comparingByValue());
        System.out.println(entryWithMinValue);

        // Or directly obtain the key, if you only need that:
        String keyWithMinValue = Collections.min(
            map.entrySet(), Entry.comparingByValue()).getKey();
        System.out.println(keyWithMinValue);
    }
}

import java.util.Collections；
导入java.util.LinkedHashMap；
导入java.util.Map；
导入java.util.Map.Entry；
公共类KeyWithMinValue
{
公共静态void main（字符串[]args）
{
Map Map=newlinkedhashmap（）；
map.put（“零”，0）；
地图.放("一",一);；
地图("二",二);；
地图放置（“三”，3）；
地图放置（“四”，4）；
//获取具有最小值的条目：
Entry entryWithMinValue=Collections.min(
map.entrySet（），Entry.comparingByValue（）；
System.out.println（entryWithMinValue）；
//或者直接获取密钥，如果您只需要：
字符串keyWithMinValue=Collections.min(
map.entrySet（），Entry.comparingByValue（））.getKey（）；
System.out.println（keyWithMinValue）；
}
}
这里的目标是提高代码的时间复杂度。可能是一个分类地图？@ChrisBolton
SortedMap
将对
键进行排序
而不是
值
。不是吗？映射是否已经填充并且它会发生变化？您可以获得O（1）查询最小查询-如果您在向映射插入数据时保持数据排序或使用优先级队列或跟踪最小值
优先级队列
将存储我的
节点
对象或其关联的
值
。它可以存储
key-value
pair？如果您非常倾向于使用字符串作为键，那么可以存储类对。然后实现
Comparable
，并且只在节点上进行比较。@MeenaChaudhary如果
节点不知道自己的值，可以将其放入一个对象（实现
Comparable
）中，然后将其放入优先级队列。@AndrewAylett您建议为
节点
对象及其
值创建一个包装器，并将其放入
优先级队列
。这可以工作，但更愿意保持代码简单和干净。但如果它能提高系统的性能，我们会尝试
Comparator<Entry<Node, Integer>> customComparator = new Comparator<>() {
        @Override
        public int compare(Entry<Node, Integer> o1, Entry<Node, Integer> o2){
            return (int)(o1.getValue() - o2.getValue());
        }

        @Override
        public boolean equals(Object obj) {
            return false;
        }
    };

Entry<Node, Integer> minVal = Collections.min(freeMap.entrySet(), customComparator);

import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;

public class KeyWithMinValue
{
    public static void main(String[] args)
    {
        Map<String, Integer> map = new LinkedHashMap<String, Integer>();

        map.put("Zero", 0);
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);
        map.put("Four", 4);

        // Obtain the entry with the minimum value:
        Entry<String, Integer> entryWithMinValue = Collections.min(
            map.entrySet(), Entry.comparingByValue());
        System.out.println(entryWithMinValue);

        // Or directly obtain the key, if you only need that:
        String keyWithMinValue = Collections.min(
            map.entrySet(), Entry.comparingByValue()).getKey();
        System.out.println(keyWithMinValue);
    }
}