java - 将多个字符串混合成所有可能的组合

Question

我有一些字符串。

1. 1

2. 2

3. 3

我如何将它们组合成所有独特的组合？

1. 123

2. 132

3. 213

4. 231

5. 312

6. 321

这是我的代码，但我想在没有 Random 类的情况下工作，因为我知道这不是最好的方法。

import java.util.Random;

public class Solution
{
    public static void main(String[] args)
    {
        String[] names = new String[]{"string1", "string2", "string3"};
        for (int i = 0; i < 9; i++) {
            Random rand = new Random();
            int rand1 = rand.nextInt(3);
            System.out.println(names[rand.nextInt(3)] +
                    names[rand1] +
                    names[rand.nextInt(3)]);
        }
    }
}

Answer 1

您可以通过为每次重复创建另一个嵌套循环来遍历数组。

for (String word1 : words) {
    for (String word2 : words) {
        for (String word3 : words) {
            System.out.println(word1 + word2 + word3);
        }
    }
}

这里是如何避免在一个组合中出现相同的词。

for (String word1 : words) {
    for (String word2 : words) {
        if ( !word1.equals(word2)) {
            for (String word3 : words) {
                if ( !word3.equals(word2) && !word3.equals(word1)) {
                    System.out.println(word1 + word2 + word3);
                }
            }
        }
    }
}

这是一个类版本，它使用回溯法能够处理多种长度。

import java.util.ArrayList;
import java.util.List;


public class PrintAllCombinations {

    public void printAllCombinations() {
        for (String combination : allCombinations(new String[] { "A", "B", "C" })) {
            System.out.println(combination);
        }
    }

    private List<String> allCombinations(final String[] values) {
        return allCombinationsRecursive(values, 0, values.length - 1);
    }

    private List<String> allCombinationsRecursive(String[] values, final int i, final int n) {
        List<String> result = new ArrayList<String>();
        if (i == n) {
            StringBuilder combinedString = new StringBuilder();
            for (String value : values) {
                combinedString.append(value);
            }
            result.add(combinedString.toString());
        }
        for (int j = i; j <= n; j++) {
            values = swap(values, i, j);
            result.addAll(allCombinationsRecursive(values, i + 1, n));
            values = swap(values, i, j); // backtrack
        }
        return result;
    }

    private String[] swap(final String[] values, final int i, final int j) {
        String tmp = values[i];
        values[i] = values[j];
        values[j] = tmp;
        return values;
    }

}

请注意，使用随机方法无法保证所有组合都被获取。因此，它应该始终遍历所有值。