Question

我有这个程序，它有一些类似于此的递归函数：

public static void lambda(HashSet<Integer> s){
    if(end(s)){
        return;
    }
    for(int i=0;i<w;i++){
        HashSet<Integer> p = (HashSet) s.clone();
        p.addAll(get_next_set());
        do_stuff_to(p);
        lambda(p);
    }
}

我正在做的是将每一组与集合联合起来。并在每个联盟上运行lambda。我运行一个分析器，发现c.clone（）操作占用了我代码的100％时间。有什么方法可以大大提高速度吗？

Answer 1

当你克隆时，你真正想做什么，也许你不需要做一个完整的修补？

提高lambda函数性能的最佳选择是扩展HashSet并使用特定于您情况的自定义克隆定义覆盖克隆定义...

我不知道有什么方法能够真正帮助你更多地了解更多信息。

Answer 2

如果我做得对，你试着做以下事情：

lambda(Set p) {
    lambda(p + further elements);
}

你可以避免克隆p例如通过重新实现列表并使用节点作为lambda的参数：

class Node {
    int content;
    Node next;

    Node(int content, Node next) {
        this.content = content;
        this.next = next;
    }
}

void lambda(Node set) {
    // add new elements to front
    Node newSet = set;

    for(Integer i : new_elements() ) {
        newSet = new Node(i, newSet);
    }

    lambda(newSet);
    // Observe that set is not modified by adding new elements
}

这是一个低级解决方案，您必须实现慢速顺序搜索/查找算法（如果您依赖于集合中的唯一元素），但根据我的经验，这样的堆栈对于大多数人来说是一个很好的解决方案递归算法。

Answer 3

这就是我为加速一切所做的，这样我就不必创建新的套装了。

public static void lambda(HashSet<Integer> s){
    if(end(s)){
        return;
    }
    ArrayList<Integer> diff = new ArrayList<Integer>();
    for(int i=0;i<w;i++){
        //an array version of the next set, it is pre-computed
        int[] a = get_next_set_array();
        for(int j=0;j<a.length;j++){
            if(!s.contains(a[j])){
               diff.add(a[j]);
            }
        }
        s.addAll(diff);
        do_stuff_to(s);
        s.removeAll(diff);
        diff.clear();
        lambda(p);
    }
}

平均来说，这个速度要快得多，并且程序在addAll和removeAll上花费的时间大致相同。

Java创建新集太慢了

3 个答案: