地图按价值集合的大小排序[重复]

Question

我正在尝试创建一个排序映射 Map<Integer,Set<Integer>>，它根据值集的 size() 对元素进行排序。

实际上，这是一个节点到连接到该节点的其他节点的映射。我想快速（O（logn））访问具有最多边缘的节点不必每次都排序。

例如顺序应该是：

3 => {1,2,4,5}
12 => {1,2,3}
14 => {3,2,3}
65 => {3,8}
6 => {2}
2 => {5}

由于TreeMap 不会这样做，因为我无法根据值进行排序，所以我可能需要滚动一些自定义内容。

编辑： Set 的大小确实可能会发生变化，这可能会使事情变得更加复杂

实现这一目标的最简单方法是什么？

Answer 1

这是一个排序示例，如何为此使用两个集合。一组按 Set::size 排序，另一组只是一个带有整数索引的普通 Map。要使用它，您必须在两个映射中保持相同的键/值对。

我不确定是否建议尝试用它制作一张地图。它有两个查找，按索引和按大小，所以它不像常规地图那样工作。这取决于您的使用模式。

package quicktest;

import static java.util.Comparator.comparing;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeMap;

public class TreeMapTest
{
   public static void main(String[] args) {
      TreeMap<Integer,Set<Integer>> index = new TreeMap<>();
      TreeMap<Set<Integer>,Integer> size = new TreeMap<>( comparing( Set::size ) );

      for( int i = 0; i < 5; i++ ) { 
         Set<Integer> set = new HashSet<>();
         for( int val = 0; val <= i; val++ ) {
            set.add( val );
         }
         index.put( i, set );
         size.put( set, i );
      }
      System.out.println( size.lastEntry() ); // largest set size
      System.out.println( index.get( 2 ) );  // random index
   }
}

Answer 2

这个呢？

public class MapAndPriority {
    Map<Integer, Set<Integer>> sets = new HashMap<Integer, Set<Integer>>();
    PriorityQueue<Set<Integer>> byLength = new PriorityQueue<Set<Integer>>(1, new Comparator<Set<Integer>>() {
        @Override
        public int compare(Set<Integer> o1, Set<Integer> o2) {
            // Compare in the reverse order!
            return o2.size() - o1.size();
        }
    });

    public void add(int i, Set<Integer> set) {
        sets.put(i, set);
        byLength.offer(set); // or Add, depending on the behavior you want
    }

    public Set<Integer> get(int i) {
        return sets.get(i);
    }

    public Set<Integer> mostNodes() {
        return byLength.peek();
    }

    public void remove(int i) {
        // sets.remove will return the removed set, so that will be removed from byLength. 
        // Need to handle case when i does not exist as a key in sets
        byLength.remove(sets.remove(i));

    }
}

如果我明白你想要什么，那么这将是：

1. 在 o(nlog(n)) 中添加新集合
2. 常规地图get()
3. 将在 o(log(n)) 中获得最大的集合 (mostNodes())

我所做的是将所有集合放在优先级队列中（沿着地图），然后为优先级队列提供一个比较器，该比较器根据大小进行比较，因此较小的大小是“较大的”。这样，当您调用peek() 时，它将返回优先级队列中的“最小值”值，由于我们的比较器，它将是最长的集合。 我没有处理各种边缘情况（比如空时删除）。

您可以查看documentation 了解更多详细信息和复杂性。