Question

我想开发一个散列函数，该函数接收BitSet对象并根据BitSet中的数字1生成散列值。此数字的计算方法是：

HttpResponse

例如：

BitSet b = new Bitset();
int card = b.cardinality();

我想要一个按以下顺序返回元素的Map：

或

我无法使用utilizzando TObjectIntCustomHashMap：

但结果与预期不符。

Answer 1

我认为，从user93335240构建的最干净的解决方案是将自定义比较器应用于TreeSet，从而允许像这样的O(nlogn)解决方案：

Set<Integer> t = new TreeSet<>((a, b) -> { a.cardinality() - b.cardinality() });
t.forEach((a) -> System.out.println(a));

您将在其中创建自己的包装程序以提供cardinality()功能的地方。

您不能使用哈希，因为它不能保证发生冲突时hashCode值的分布。您可以尝试类似线性探测的方法，但不能保证它是正确的。

实际上，如果您要获得O(nlogn)子解决方案，那就是disproving the lower bound on the comparison sort based model。

Answer 2

即使我认为@MathBunny也是对您的答案……与其使用当前哈希表隐含的副作用，不如使用专用结构满足您的要求……这是您要搜索的内容

public class HashTest {
    public static class BitSet extends java.util.BitSet {

        private static final long serialVersionUID = 4014851086683360760L;

        public BitSet(int i) {
            super(i);
        }

        public BitSet() {
            super();
        }

        @Override
        public int hashCode() {
            return stream().map(i -> (int) Math.pow(2, i)).sum();
        }

        @Override
        public boolean equals(Object obj) {
            if (obj instanceof java.util.BitSet) {
                return obj == null ? false : obj.hashCode() == hashCode();
            } else {
                return false;
            }
        }
    }

//  1
//  010
//  110
//  111
    public static void main(String[] args) {
        BitSet bitset1 = new BitSet(1);
        bitset1.set(0);
        BitSet bitset2 = new BitSet(3);
        bitset2.set(1);
        BitSet bitset3 = new BitSet(3);
        bitset3.set(1);
        bitset3.set(2);
        BitSet bitset4 = new BitSet(3);
        bitset4.set(0);
        bitset4.set(1);
        bitset4.set(2);
        Map<BitSet, String> map = new HashMap<>();
        map.put(bitset1, "bitset1");
        map.put(bitset2, "bitset2");
        map.put(bitset3, "bitset3");
        map.put(bitset4, "bitset4");
        map.forEach((k, v) -> System.out.println(v));

    }

}

基于基数的自定义哈希函数

2 个答案: