标签: sortedmap

是否有Python设计决策(PEP)阻止将已排序的容器添加到Python中？

(OrderedDict不是已排序的容器,因为它是按插入顺序排序的.)

我有一个

 Map<Float, MyObject>

根据浮点数保持地图排序的最佳方法是什么？

是SortedMap最好的答案吗？TreeMap？我该如何使用它？

我只创建一次地图并替换MyObject频繁使用myMap.put()和myMap.get().

我需要一个TreeMap的比较器.我应该在我的TreeMap的构造函数中匿名写这个吗？我怎么能写我的比较器.目前,Java不喜欢我的代码(我可以匿名执行此操作吗？):

SortedMap<String, Double> myMap = 
    new TreeMap<String, Double>(new Comparator<Entry<String, Double>>()
    {
        public int compare(Entry<String, Double> o1, Entry<String, Double> o2)
        {
            return o1.getValue().compareTo(o2.getValue());
        } 
    });

1. 我可以匿名进行上述操作吗？
2. 我怎么能这样做？
3. 我想通过Value而不是Key对myMap进行排序

我正在使用字符串的TreeMap TreeMap<String, String>,并使用它来实现单词的Dictionay.

然后我有一个文件集合,并希望在字典定义的向量空间(单词空格)中创建每个文件的表示.

每个文件都应该有一个向量来表示它,具有以下属性:

• 矢量应该与字典大小相同
• 对于文件中包含的每个单词,向量在与字典中的单词位置对应的位置应该具有1
• 对于未包含在文件中的每个单词,向量在与字典中的单词位置对应的位置应该具有-1

所以我的想法是使用a Vector<Boolean>来实现这些向量.(这种表示集合中文档的方式称为布尔模型 - http://www.site.uottawa.ca/~diana/csi4107/L3.pdf)

我在创建这个向量的过程中遇到的问题是我需要一种方法来查找字典中单词的位置,如下所示:

String key;
int i = get_position_of_key_in_Treemap(key); <--- purely invented method...

1)我可以在TreeMap上使用这样的方法吗？如果没有,你能不能提供一些代码来帮助我自己实现它？

2)TreeMap上是否有一个迭代器(它按字母顺序排列),我可以获得它的位置？

3)最终我应该使用另一个类来实现字典？(如果你认为使用TreeMaps我不能做我需要的)如果是的话,哪个？

提前致谢.

增加部分:

由dasblinkenlight提出的解决方案看起来很好,但是存在复杂性问题(由于将密钥复制到数组中而与字典的维度呈线性关系),并且不能接受为每个文件执行此操作的想法.

对我的问题还有其他想法吗？

我是Scala的新手.我在我的代码中使用了SortedMap,我想使用mapValues创建一个新的地图,并对值进行一些转换.

mapValues函数返回一个新的Map,而不是返回一个新的SortedMap,然后我必须将其转换为SortedMap.

例如

val my_map = SortedMap(1 -> "one", 0 -> "zero", 2 -> "two")
val new_map = my_map.mapValues(name => name.toUpperCase)
// returns scala.collection.immutable.Map[Int,java.lang.String] = Map(0 -> ZERO, 1 -> ONE, 2 -> TWO)
val sorted_new_map = SortedMap(new_map.toArray:_ *)

这看起来效率低下 - 最后一次转换可能会再次对键进行排序,或者至少验证它们是否已排序.

我可以使用普通的map函数,它既可以对键和值进行操作,也可以故意不改变转换函数中的键.这看起来太低效,因为执行地图可能假设转换可以(在的情况下,如:改变键的顺序my_map.map(tup => (-tup._1, tup._2)) -所以它可能"重新排序"他们.

有人熟悉Map和SortedMap的内部实现,可以告诉我我的假设是否正确吗？编译器能否自动识别出密钥没有重新排序？是否有内部原因导致mapValues不应返回SortedMap？有没有更好的方法来转换地图的值而不会失去键的顺序？

谢谢

EnumMap<K extends Enum<K>, V> 在 Java 中，按照相关枚举的定义明确排序，正如您在 javadoc 中看到的：

枚举映射以其键的自然顺序（声明枚举常量的顺序）维护。这反映在由集合视图返回的迭代（keySet()，entrySet()，和values()）。

我需要的是SortedMap使用枚举作为键类型。我想使用headMap()or 之类的方法firstKey()，但我想从EnumMaps增加的 cpu+memory 性能中获利。一个TreeMap听起来像是太多的开销在这里。

问题：这是否只是在实现中遗漏了，是懒惰（源自AbstractMap）还是有充分的理由为什么EnumMap不是SortedMap？

可能重复:
Java:SortedMap,TreeMap,Comparable？如何使用？

我正在使用Java JungI图形包和Netbeans 7.我从Java得到以下错误:

 Exception in thread "main" java.lang.ClassCastException: graphvisualization.MyVertex cannot be cast to java.lang.Comparable
    at java.util.TreeMap.put(TreeMap.java:542)

以下是与错误相关的代码:

SortedMap<MyVertex, Double> vMap = new TreeMap<MyVertex, Double>();
       double curRank = 0;
       for(MyVertex v: g.getVertices())                 //g is a SparseGraph<MyVertex, MyEdge>
       {
           curRank = vertexRank.getVertexScore(v);
           vMap.put(v, curRank);                        //**Here is my Error**
       }

MyVertex类是我为图表制作的一个类.以下是MyVertex的代码

public class MyVertex 
{
    int vID;                    //id for this vertex
    double centrality;          //centrality measure for this vertex
    int degree;                 //the degree of this vertex

    public MyVertex(int id)
    {
        this.vID …

我在使用Scala的SortedMap [A​​,B]时遇到了一些未经授权的陌生感.如果我将SortedMap [A​​,B]"a"的引用声明为Map [A​​,B]类型,那么对"a"的映射操作将产生一个非有序映射实现.

例:

import scala.collection.immutable._

object Test extends App {
    val a: Map[String, String] = SortedMap[String, String]("a" -> "s", "b" -> "t", "c" -> "u", "d" -> "v", "e" -> "w", "f" -> "x")
    println(a.getClass+": "+a)

    val b = a map {x => x}  // identity
    println(b.getClass+": "+b)
}

以上的输出是:

class scala.collection.immutable.TreeMap:Map(a - > s,b - > t,c - > u,d - > v,e - > w,f - > x)
class scala.collection.immutable.HashMap $ HashTrieMap:Map(e - > w,f - …

(我正在使用Scala nightlies,并在2.8.0b1 RC4中看到相同的行为.我是Scala的新手.)

我有两个SortedMap我想组成的联盟.这是我想要使用的代码:

import scala.collection._

object ViewBoundExample {
    class X
    def combine[Y](a: SortedMap[X, Y], b: SortedMap[X, Y]): SortedMap[X, Y] = {
        a ++ b
    }
    implicit def orderedX(x: X): Ordered[X] = new Ordered[X] { def compare(that: X) = 0 }
}

这里的想法是'隐含'语句意味着Xs可以转换为Ordered[X]s,然后将SortedMaps 组合成另一个SortedMap,而不仅仅是一个映射.

当我编译时,我得到了

sieversii:scala-2.8.0.Beta1-RC4 scott$ bin/scalac -versionScala compiler version
2.8.0.Beta1-RC4 -- Copyright 2002-2010, LAMP/EPFL

sieversii:scala-2.8.0.Beta1-RC4 scott$ bin/scalac ViewBoundExample.scala
ViewBoundExample.scala:8: error: type arguments [ViewBoundExample.X] do not
    conform to method …

如果我NavigableMap已经形成了。floorEntry()执行操作所需的时间是多少？会是O(1)还是O(logn)？

例如：

如果我有NavigableMapn 个间隔，并且我使用map.floorEntry(k)一些 random k，那么执行操作的时间复杂度是多少？