Question

我正在尝试编写一个递归方法，允许我对数组中所有可能的整数变量求和。

EG。对于具有以下值[1,2,3,4]

的数组

结果：[1,2]，[1,3]，[1,4]，[2,1]，[2,3]，[2,4]，[3,1]，[3， 2]，[3,4]，[4,1]，[4,2]，[4,3]，[1,2,3]，[1,2,4]，[2,1,3] ，[2,1,4]等等。

我对递归完全不熟悉。我的理解是将问题分成一个较小的问题。但我似乎无法看到这种情况。有人可以帮助我吗？

编辑：

class Stick {

    public int sum(ArrayList<Integer> array) { 
        int total = 0;
        for(int i = 0; i < array.size(); i++) {
            total += array.get(i);
        }

        return total;
    }

    public void permute(ArrayList<Integer> in, ArrayList<Integer> out) {
        if(out.size() > 0) { print(out); System.out.println(sum(out)); }

        for(int i = 0; i < in.size(); i++) { 
            int item = in.get(i);
            in.remove(i);
            out.add(item);
            permute(in , out);
        }
    }

    public void print(ArrayList<Integer> integer) {
        System.out.print("[");
        for(int i = 0; i < integer.size(); i++) {
            System.out.print(integer.get(i) + ", ");
        }
        System.out.print("]");
    }
    public static void main(String[] args) {
        ArrayList<Integer> in = new ArrayList<Integer>();
        ArrayList<Integer> out = new ArrayList<Integer>();
        in.add(1); in.add(2); in.add(3); in.add(4);

        Stick stick = new Stick();
        stick.permute(in, out);
    }
}

Answer 1

static ArrayList<int[]> permutations(int[] a) {
    ArrayList<int[]> ret = new ArrayList<int[]>();
    permutation(a, 0, ret);
    return ret;
}

public static void permutation(int[] arr, int pos, ArrayList<int[]> list) {
    if (arr.length - pos == 1) {
        list.add(arr.clone());
    } else {
        for (int i = pos; i < arr.length; i++) {
            swap(arr, pos, i);
            permutation(arr, pos + 1, list);
            swap(arr, pos, i);
        }
    }
}

public static void swap(int[] arr, int pos1, int pos2) {
    int h = arr[pos1];
    arr[pos1] = arr[pos2];
    arr[pos2] = h;
}

public static void main(String[] args) {
    int[] x = {1, 2, 3, 4};
    for(int i[] : IntRecursion.permutations(x)) {
        System.out.println(Arrays.toString(i));
    }

}

我认为这是你正在寻找的。

Answer 2

这是一种有效的递归方法：

编写一个递归例程permute，它包含两个数组：arrayIn和arrayOut。 arrayIn包含尚未使用的值，arrayOut包含部分形成的结果。
将使用arrayIn调用该程序，其中包含完整的值数组，arrayOut将从空开始。

在每一步中，您都会通过从arrayOut获取值并将它们附加到数组中来构建arrayIn。这是您正在寻找的较小的案例。每个步骤arrayIn变小，直到您到达arrayIn为空的基本情况。

以下是 Ruby 中的解决方案。如果你不熟悉 Ruby 语法，我试图让它变得可读：

# function to sum up the values of an array
def sum(array)
    total = 0
    for elem in array
        total += elem
    end

    # return the total
    total
end

def permute(arrayIn, arrayOut)
    if arrayOut.count > 0
        # print out the array
        puts arrayOut.inspect

        # print out the total
        puts "total is #{sum(arrayOut)}"
    end

    # For each element in turn in arrayIn...
    for elem in arrayIn
        # remove element from arrayIn, add it to arrayOut, and recurse
        permute(arrayIn - [elem], arrayOut + [elem])
    end
end

当我们用数组[1,2,3]运行它时：

    permute([1,2,3], [])

输出结果为：

[1]
total is 1
[1, 2]
total is 3
[1, 2, 3]
total is 6
[1, 3]
total is 4
[1, 3, 2]
total is 6
[2]
total is 2
[2, 1]
total is 3
[2, 1, 3]
total is 6
[2, 3]
total is 5
[2, 3, 1]
total is 6
[3]
total is 3
[3, 1]
total is 4
[3, 1, 2]
total is 6
[3, 2]
total is 5
[3, 2, 1]
total is 6

递归以获取数组中的所有变量和

2 个答案: