Java 字符串的排列…逻辑错误？

我试图生成给定字符串的所有排列

我使用的逻辑

假设string=abcd

1） 然后我在第一个循环的第一个位置固定“a”（和类似的每个字符..第一次迭代-abcd，第二次bacd，第三次cabd..）

2） 然后通过移动第二个字符，即“b”，生成字符串 在所有的地方。。像abcd，acbd，acdb

3） 然后我用 第二个字符，然后再次重复第二步

4） 我将abcd更改为bacd（每个字符n so）并重复步骤 2,3

现在，这不应该生成所有可能的组合..而且我还使用树集删除重复的条目。。。 但不知怎的，它产生的排列比实际的少…就像4个字符，20个排列

下面是相同的代码

import java.util.*;

public class practice4 {


    public static void main(String[] args) {



        TreeSet t = new TreeSet();
        String arr[] = new String[100];
        int z = -1;
        StringBuffer s5 = new StringBuffer("abcde");


        for (int i = 0; i <= s5.length() - 1; i++) {

            char ch = s5.charAt(0);
            s5.setCharAt(0, s5.charAt(i));
            s5.setCharAt(i, ch);

            StringBuffer s3 = new StringBuffer(s5);

            for (int j = 1; j <= s3.length() - 1; j++) {

                StringBuffer s2 = new StringBuffer(s3);
                // System.out.println(s2);

                z++;
                arr[z] = s2.toString();

                for (int k = 1; k < s3.length() - 1; k++) {

                    char ch2 = s2.charAt(k);
                    s2.setCharAt(k, s2.charAt(k + 1));
                    s2.setCharAt(k + 1, ch2);
                    // System.out.println(s2);

                    z++;
                    arr[z] = s2.toString();

                }

                if (j >= s3.length() - 1)
                    break;
                char ch3 = s3.charAt(1);

                s3.setCharAt(1, s3.charAt(j + 1));
                s3.setCharAt(j + 1, ch3);

            }

            System.out.println("dooone");

            System.out.println(z);
            for (int x = 0; x <= z; x++) {

                t.add(arr[x]);

            }

        }

        System.out.println(t.size());
        Iterator i55 = t.iterator();
        while (i55.hasNext()) {
            System.out.println(i55.next());
        }
    }

}

import java.util.*；
公开课实习4{
公共静态void main（字符串[]args）{
树集=新树集（）；
字符串arr[]=新字符串[100]；
int z=-1；
StringBuffer s5=新的StringBuffer（“abcde”）；
对于（int i=0；i，您可以查看以下任何帖子以获取帮助：


或

对于长度为n的输入字符串，您的3个嵌套循环最多可以生成n^3个字符串。但是，排列的数量要大得多（n！），因此对于大n，结果集必须是部分的

此外，您认为逻辑应该生成所有排列的论点是错误的，因为每个字符都位于每个可能的位置。每个元素访问所有位置的事实并不意味着访问所有可能的排列。例如，对于n=3：

123
213
321
312

所有项目显示在所有位置，但列表仍缺少序列132和231

如果递归是可接受的，考虑下面的解决方案：
public static Collection<String> permutations(String s) {
    ArrayList<String> l = new ArrayList<String>();
    permutations(s.toCharArray(), 0, l);
    return l;
  }

  private static void permutations(char[] chars, int i, ArrayList<String> l) {
    if (i == chars.length) {
      l.add(new String(chars));
      return;
    }

    for (int j = i; j < chars.length; j++) {
      swap(chars, i, j);
      permutations(chars, i + 1, l);
      swap(chars, i, j);
    }
  }

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

  private static Collection<String> permutations2(String str) {
    ArrayList<String> listNew = new ArrayList<String>();
    ArrayList<String> listPrev = new ArrayList<String>();

    char chr = str.charAt(0);
    listPrev.add("" + chr);

    for (int i = 1; i < str.length(); i++) {
      chr = str.charAt(i);

      for (String s : listPrev) {
        for (int idx = 0; idx <= s.length(); idx++) {
          String perm = s.substring(0, idx) + chr + s.substring(idx);
          listNew.add(perm);
        }
      }

      listPrev = listNew;
      listNew = new ArrayList<String>();
    }
    return listPrev;
  }

公共静态集合置换（字符串s）{
ArrayList l=新的ArrayList（）；
置换（s.toCharArray（），0，l）；
返回l；
}
私有静态空置换（char[]chars，int i，ArrayList l）{
如果（i==字符长度）{
l、 添加（新字符串（字符））；
返回；
}
对于（int j=i；j

该算法背后的归纳思想是，排列集是长度为n-1的所有排列的并集，通过选择第一个字符并递归地延续尾部而得到。假设输入字符串没有重复的字符，该并集是不相交的，因此我们不必处理重复的

非递归解决方案：

public static Collection<String> permutations(String s) {
    ArrayList<String> l = new ArrayList<String>();
    permutations(s.toCharArray(), 0, l);
    return l;
  }

  private static void permutations(char[] chars, int i, ArrayList<String> l) {
    if (i == chars.length) {
      l.add(new String(chars));
      return;
    }

    for (int j = i; j < chars.length; j++) {
      swap(chars, i, j);
      permutations(chars, i + 1, l);
      swap(chars, i, j);
    }
  }

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

  private static Collection<String> permutations2(String str) {
    ArrayList<String> listNew = new ArrayList<String>();
    ArrayList<String> listPrev = new ArrayList<String>();

    char chr = str.charAt(0);
    listPrev.add("" + chr);

    for (int i = 1; i < str.length(); i++) {
      chr = str.charAt(i);

      for (String s : listPrev) {
        for (int idx = 0; idx <= s.length(); idx++) {
          String perm = s.substring(0, idx) + chr + s.substring(idx);
          listNew.add(perm);
        }
      }

      listPrev = listNew;
      listNew = new ArrayList<String>();
    }
    return listPrev;
  }

私有静态集合置换2（字符串str）{
ArrayList listNew=新的ArrayList（）；
ArrayList listPrev=新的ArrayList（）；
char chr=str.charAt（0）；
列表上加（“+chr”）；
对于（int i=1；i对于（int idx=0；idx我没有完全理解您的解释，但只要看看您的代码有3个嵌套循环这一事实，我就知道它在字符串长度大于3的情况下不起作用。生成排列（没有重复）的更好方法是尝试将每个字符放在位置1，并且对于每种可能性，调用例程re粗略地找到剩余字符的所有排列的列表。然后你只需将每个这样的子排列附加到当前的第一个字符。这篇文章对所需的算法有一个很好的解释：@j_random_hacker..是的，它不能处理3个或更多字符..事实上它只能处理3个字符。但是is逻辑应该生成所有组合，因为每个字符都在每个可能的位置…那么我无法理解为什么它不会…如果可以，请帮助，否则我将不得不尝试递归进行…谢谢，但不谢谢..请回答，如果你能帮助解决错误的逻辑，但我将尝试提出另一个w算法：）