数组的Java置换

我有一个数组：

String wordArr[]=new String[3];

    [1 2 3]

我想用上面的所有组合形成数组

说

123 132 213 231 321 312

---

有谁能告诉我如何在java中找到所需的数组数量和逻辑

---

我正在研究如何用所有可能的组合遍历数组。比如说，如果我第一次用123迭代，那么下次我应该迭代132和213，以此类推……

这是用于生成任何数组的置换的伪代码a

Array permutations(a):
    if size(a) == 0 then return [];
    else:
        Array result;
        for i in range(size(a)):
            for t in permutations(a.remove(i)):
                result.push(Array(a[i]) + t)
        return result

---

希望这有意义，我将尝试为此编写java代码并尽快上传。

这是用于生成任何数组排列的伪代码a

Array permutations(a):
    if size(a) == 0 then return [];
    else:
        Array result;
        for i in range(size(a)):
            for t in permutations(a.remove(i)):
                result.push(Array(a[i]) + t)
        return result

希望这有意义，我将尝试为此编写java代码并尽快上传。

应用于置换的实现非常有用。基本思想是，对于从0到数组长度的索引

loc

，枚举

arr[loc]

我已经用Java实现了以下内容，但它可以用任何语言实现

import java.util.*;

public class PermutationTest{

    private static void swap(char[] arr, int i, int j) {
        char tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    private static void permutations(char[] arr, int loc, int len, ArrayList<String> result) {
        if (loc == len) {
            result.add(new String(arr));
            return;
        }

        // Pick the element to put at arr[loc]
        permutations(arr, loc + 1, len, result);
        for (int i = loc + 1; i < len; i++) {
            // Swap the current arr[loc] to position i
            swap(arr, loc, i);
            permutations(arr, loc + 1, len, result);
            // Restore the status of arr to perform the next pick
            swap(arr, loc, i);
        }
    }

    public static ArrayList<String> permutations(String str) {
        ArrayList<String> result = new ArrayList<String>();
        if (str.length() == 0) { return result; }
        permutations(str.toCharArray(), 0, str.length(), result);
        return result;
    }

    public static void main(String []args){
        ArrayList<String> result = permutations("123");
        for (String str : result) {
            System.out.println(str);   
        }
    }
}

import java.util.*；
公共类排列测试{
私有静态无效交换（char[]arr，int i，int j）{
char tmp=arr[i]；
arr[i]=arr[j]；
arr[j]=tmp；
}
私有静态空置换（char[]arr，int loc，int len，ArrayList result）{
如果（loc==len）{
添加（新字符串（arr））；
返回；
}
//选择要放置在arr[loc]的元素
排列（arr，loc+1，len，result）；
对于（int i=loc+1；i

应用于置换的实现非常有用。基本思想是，对于从0到数组长度的索引

loc

，枚举

arr[loc]

我已经用Java实现了以下内容，但它可以用任何语言实现

import java.util.*;

public class PermutationTest{

    private static void swap(char[] arr, int i, int j) {
        char tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    private static void permutations(char[] arr, int loc, int len, ArrayList<String> result) {
        if (loc == len) {
            result.add(new String(arr));
            return;
        }

        // Pick the element to put at arr[loc]
        permutations(arr, loc + 1, len, result);
        for (int i = loc + 1; i < len; i++) {
            // Swap the current arr[loc] to position i
            swap(arr, loc, i);
            permutations(arr, loc + 1, len, result);
            // Restore the status of arr to perform the next pick
            swap(arr, loc, i);
        }
    }

    public static ArrayList<String> permutations(String str) {
        ArrayList<String> result = new ArrayList<String>();
        if (str.length() == 0) { return result; }
        permutations(str.toCharArray(), 0, str.length(), result);
        return result;
    }

    public static void main(String []args){
        ArrayList<String> result = permutations("123");
        for (String str : result) {
            System.out.println(str);   
        }
    }
}

import java.util.*；
公共类排列测试{
私有静态无效交换（char[]arr，int i，int j）{
char tmp=arr[i]；
arr[i]=arr[j]；
arr[j]=tmp；
}
私有静态空置换（char[]arr，int loc，int len，ArrayList result）{
如果（loc==len）{
添加（新字符串（arr））；
返回；
}
//选择要放置在arr[loc]的元素
排列（arr，loc+1，len，result）；
对于（int i=loc+1；i
1234
是否应该有更多的排列，例如
4132
？对于
1234
，应该有24（4！）个排列，而不仅仅是8个。如果没有，请解释这些“排列”背后的逻辑。另外，你有没有尝试过什么，比如在这里寻找相关的问题？是的，你是对的。我正在研究如何迭代一个包含所有可能组合的数组。假设我第一次用123迭代，那么下次我应该迭代132和213，以此类推……1324、1342、1423、1432、2314、2341、2413、2431、3124、3142、3214、3241、4123、4132、4213和4231在哪里？“如何找到所需的数组数”？查找“阶乘”取数组并将其分成若干部分
1234
，例如
4132
，是否应该有更多的排列？对于
1234
，应该有24（4！）个排列，而不仅仅是8个。如果没有，请解释这些“排列”背后的逻辑。另外，你有没有尝试过什么，比如在这里寻找相关的问题？是的，你是对的。我正在研究如何迭代一个包含所有可能组合的数组。假设我第一次用123迭代，那么下次我应该迭代132和213，以此类推……1324、1342、1423、1432、2314、2341、2413、2431、3124、3142、3214、3241、4123、4132、4213和4231在哪里？“如何找到所需的数组数”？查找“阶乘”将数组拆分为部分这正是我想要的！这正是我想要的！