Java 生成特定长度的所有置换

假设我们有一个字母“abcdefghiklimnop”。我怎样才能以一种高效的方式，以五人一组的方式递归地生成这个字母表的重复排列

我已经为此挣扎了几天了。任何反馈都会有帮助

本质上，这与：

但是，我只想要整个字符串的长度为5的排列。我一直没能弄明白这一点

因此，对于“abcdefghiklimnop”中长度为5的所有子串，找到该子串的置换。例如，如果这个子串是abcdef，我想要它的所有置换，或者如果这个子串是defli，我想要这个子串的所有置换。下面的代码为我提供了字符串的所有排列，但我想使用它来查找字符串大小为5的所有子字符串的所有排列

    public static void permutation(String str) { 
    permutation("", str); 
}
private static void permutation(String prefix, String str) {
    int n = str.length();
    if (n == 0) System.out.println(prefix);
    else {
        for (int i = 0; i < n; i++)
            permutation(prefix + str.charAt(i), str.substring(0, i) + str.substring(i+1, n));
    }
}

publicstaticvoidpermutation（stringstr）{
排列（“，str）；
}
私有静态无效置换（字符串前缀、字符串str）{
int n=str.length（）；
如果（n==0）System.out.println（前缀）；
否则{
对于（int i=0；i

要递归地从字符串中选取五个字符，请遵循一个简单的算法：

• 到目前为止，您的方法应该得到一个填充部分，以及五个字符排列中需要一个字符的第一个位置
• 如果第一个需要角色的位置在五个以上，那么您就完成了；打印到目前为止您拥有的组合，然后返回
• 否则，将每个字符放在排列中的当前位置，并进行递归调用

这在Java中要短得多：

private static void permutation(char[] perm, int pos, String str) {
    if (pos == perm.length) {
        System.out.println(new String(perm));
    } else {
        for (int i = 0 ; i < str.length() ; i++) {
            perm[pos] = str.charAt(i);
            permutation(perm, pos+1, str);
        }
    }
}

---

要递归地从字符串中选取五个字符，请遵循一个简单的算法：

• 到目前为止，您的方法应该得到一个填充部分，以及五个字符排列中需要一个字符的第一个位置
• 如果第一个需要角色的位置在五个以上，那么您就完成了；打印到目前为止您拥有的组合，然后返回
• 否则，将每个字符放在排列中的当前位置，并进行递归调用

这在Java中要短得多：

private static void permutation(char[] perm, int pos, String str) {
    if (pos == perm.length) {
        System.out.println(new String(perm));
    } else {
        for (int i = 0 ; i < str.length() ; i++) {
            perm[pos] = str.charAt(i);
            permutation(perm, pos+1, str);
        }
    }
}

---

所有五个字符的排列将包含在每个排列的前五个字符集中。例如，如果您想要四个字符字符串“abcd”的所有两个字符排列，您可以从所有排列中获得它们： ‘abcd’、‘abdc’、‘acbd’、‘acdb’…'dcba'

---

因此，在检查排列是否已存储后，您可以将它们存储到列表中，而不是在方法中打印它们。列表可以传递给函数或静态字段，具体取决于您的规范。

所有五个字符的排列将包含在每个排列的前五个字符集中。例如，如果您想要四个字符字符串“abcd”的所有两个字符排列，您可以从所有排列中获得它们： ‘abcd’、‘abdc’、‘acbd’、‘acdb’…'dcba'

---

因此，在检查排列是否已存储后，您可以将它们存储到列表中，而不是在方法中打印它们。列表可以传递到函数或静态字段，具体取决于您的规范。

这可以通过位操作轻松完成

private void getPermutation(String str, int length)
        {
            if(str==null)
                return;
            Set<String> StrList = new HashSet<String>();
            StringBuilder strB= new StringBuilder();
            for(int i = 0;i < (1 << str.length()); ++i)
            {
                strB.setLength(0); //clear the StringBuilder
                if(getNumberOfOnes(i)==length){
                  for(int j = 0;j < str.length() ;++j){
                    if((i & (1 << j))>0){  // to check whether jth bit is set (is 1 or not)
                        strB.append(str.charAt(j));
                    }
                }
                StrList.add(strB.toString());
                }
            }
            System.out.println(Arrays.toString(StrList.toArray()));
        }

    private int getNumberOfOnes (int n) // to count how many numbers of 1 in binary representation of n
    {
        int count=0;
        while( n>0 )
        {
        n = n&(n-1);
           count++;
        }
        return count;
    }

private void getPermutation（字符串str，int-length）
{
如果（str==null）
返回；
Set StrList=newhashset（）；
StringBuilder strB=新的StringBuilder（）；
对于（int i=0；i<（10）
{
n=n&（n-1）；
计数++；
}
返回计数；
}

这可以通过位操作轻松完成

private void getPermutation(String str, int length)
        {
            if(str==null)
                return;
            Set<String> StrList = new HashSet<String>();
            StringBuilder strB= new StringBuilder();
            for(int i = 0;i < (1 << str.length()); ++i)
            {
                strB.setLength(0); //clear the StringBuilder
                if(getNumberOfOnes(i)==length){
                  for(int j = 0;j < str.length() ;++j){
                    if((i & (1 << j))>0){  // to check whether jth bit is set (is 1 or not)
                        strB.append(str.charAt(j));
                    }
                }
                StrList.add(strB.toString());
                }
            }
            System.out.println(Arrays.toString(StrList.toArray()));
        }

    private int getNumberOfOnes (int n) // to count how many numbers of 1 in binary representation of n
    {
        int count=0;
        while( n>0 )
        {
        n = n&(n-1);
           count++;
        }
        return count;
    }

private void getPermutation（字符串str，int-length）
{
如果（str==null）
返回；
Set StrList=newhashset（）；
StringBuilder strB=新的StringBuilder（）；
对于（int i=0；i<（10）
{
n=n&（n-1）；
计数++；
}
返回计数；
}

类字符串长度排列
{
//主要的递归方法
//尽可能地打印
//长度为k的字符串
静态void printallklengtrec（字符[]集，字符串前缀，
整数n，整数k）
{
//基本情况：k为0，
//打印前缀
如果（k==0）
{
System.out.println（前缀）；
返回；
}
//逐个添加所有字符
//从集合递归地
//要求k等于k-1
对于（int i=0；i

类字符串长度排列
{
//主要的递归方法
//尽可能地打印
//长度为k的字符串
静态void printallklengtrec（字符[]集，字符串前缀，
整数n，整数k）
{
//基本情况：k为0，
//打印前缀
如果（k==0）
{
System.out.println（前缀）；
返回；
}
//逐个添加所有字符
//从集合递归地
//要求k等于k-1
对于（int i=0；i<