使用迭代器使用递归查找字符串的排列

Question

正如标题所暗示的，我很难尝试递归地确定给定String 的所有排列。问题是 String 必须通过对象的构造函数给出，然后一个一个地找到每个排列。基本上，它必须像这样工作：

PermutationIterator iter = new PermutationIterator("eat");
while (iter.hasMorePermutations())
   System.out.println(iter.nextPermutation());

这是我正在使用但似乎不起作用的代码，我不知道如何修复它。

public class PermutationIterator {

    private String word;
    private int pos;
    private PermutationIterator tailIterator;
    private String currentLetter;

    public PermutationIterator(String string) {
        word = string;
        pos = 0;
        currentLetter = string.charAt(pos) + "";
        if (string.length() > 1)
            tailIterator = new PermutationIterator(string.substring(pos + 1));
    }

    public String nextPermutation() {
        if (word.length() == 1) {
            pos++;
            return word;
        } else if (tailIterator.hasMorePermutations()) {
            return currentLetter + tailIterator.nextPermutation();
        } else {
            pos++;
            currentLetter = word.charAt(pos) + "";
            String tailString = word.substring(0, pos) + word.substring(pos + 1);
            tailIterator = new PermutationIterator(tailString);
            return currentLetter + tailIterator.nextPermutation();
        }

    }

    public boolean hasMorePermutations() {
        return pos <= word.length() - 1;
    }
}

现在程序打印“eat”和“eta”，但之后它通过第二个堆栈的StringIndexOutOfBounds 错误。非常感谢任何解决此问题的帮助。

Answer 1

让我帮助诊断您的问题，而不是仅仅提供修复，然后您就可以尝试修复它。

如果您仔细查看您的代码，您会发现hasMorePermutations 条件在pos == word.length() - 1 时通过。这意味着nextPermutation 将在pos 指向字符串中的最后一个字符时运行。但在这种情况下，当第三个分支执行时，您递增pos，然后调用word.substring(pos + 1)。此时pos + 1 将大于将引发异常的字符串的长度。

我希望修复会相当容易。

Answer 2

试试这个代码 - 为任何给定的字符串生成排列

package testing;

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

public class Permutations {

	/*
	 * You will get n! (factorial) - permutations from this
	 * 
	 * Just like this Example: abc (3! = 6 permutations) [abc acb bac bca cab
	 * cbc]
	 */
	static String str = "abcd";
	static char[] ch = str.toCharArray();
	static List<String> s1 = new ArrayList<>();
	static List<String> s2 = new ArrayList<>();

	public static void main(String[] args) {

		// s1 - list stores initial character from the string
		s1.add(String.valueOf(ch[0]));

		// recursive loop - char by char
		for (int k = 1; k < ch.length; k++) {

			// adds char at index 0 for all elements of previous iteration
			appendBefore(s1, ch[k]);
			// adds char at last index for all elements of previous iteration
			appendAfter(s1, ch[k]);
			// adds char middle positins like a^b^C - if prev list stores
			// elements
			// whose size() is 3 - then it would have 2 positions fill
			/*
			 * say d is next char - d should be filled in _^_^_ _ positions are
			 * previous permuions for 3 chars a,b,c(i.e 6 permutations
			 */
			appendMiddle(s1, ch[k], k);
			// for every iteration first clear s1 - to copy s2, which contains
			// previous permutatons
			s1.clear();
			// now copy s2 to s1- then clear s2
			// - this way finally s2 contains all the permutations
			for (int x = 0; x < s2.size(); x++) {
				s1.add(s2.get(x));
			}
			System.out.println(s1);
			System.out.println(s1.size());
			s2.clear();
		}

	}

	private static void appendMiddle(List str, char ch, int positions) {

		for (int pos = 1; pos <= positions - 1; pos++) {
			for (int i = 0; i < str.size(); i++) {
				s2.add(str.get(i).toString().substring(0, pos) + String.valueOf(ch)
						+ str.get(i).toString().substring(pos, str.get(i).toString().length()));

			}
		}

	}

	private static void appendBefore(List str, char ch) {

		for (int i = 0; i < str.size(); i++) {
			s2.add(String.valueOf(ch) + str.get(i));

		}

	}

	private static void appendAfter(List str, char ch) {

		for (int i = 0; i < str.size(); i++) {
			s2.add(str.get(i) + String.valueOf(ch));

		}
	}

}

Answer 3

在你的 hasMorePermutation 方法中做一点改变来解决 StringIndexOutOfBounds 异常。

public boolean hasMorePermutations()
{
    return pos < word.length() - 1;
}