Java 重复排列

在我开始之前，我必须为提出另一个重复排列的案例道歉。我已经浏览了大部分搜索结果，并没有真正找到我要找的内容。我已经阅读了有关词典编纂顺序的内容，并已将其付诸实施。对于这个问题，我假设实现一个递归方法，该方法打印出长度为n的所有字符串，这些字符串仅由a和b组成，a和b的数量相等。字符串必须按词汇顺序一次打印一行。例如，一个电话：

printBalanced(4);

将打印字符串：

aabb
abab
abba
baab
baba
bbaa

这是密码

public static void main(String[] args){
    printBalanced(4);
}


public static void printBalanced(int n){
    String letters = "";

    //string to be duplicates of "ab" depending the number of times the user wants it
    for(int i =0; i<n/2;i++){
        letters += "ab";
    }


    balanced("",letters);

}

private static void balanced(String prefix, String s){

    int len = s.length();

    //base case
    if (len ==0){
        System.out.println(prefix);
    }
    else{
            for(int i = 0; i<len; i++){     

                balanced(prefix + s.charAt(i),s.substring(0,i)+s.substring(i+1,len));


            }

        }
    }

正如你所看到的，我得到了很多复制品。这部分是因为要求只使用“a”和“b”字符。如果是“abcd”或“0123”，则不会发生重复。我读过关于使用arraylist并存储所有结果，然后循环N个元素以检查重复项，然后删除它的内容。这似乎不是最好的方法。有人可以分享其他更好的解决方案吗？=）

使用SortedSet的我的解决方案：

import java.util.Iterator;
import java.util.SortedSet;
import java.util.TreeSet;

public class BalancedStrings {

public static void main(String[] args){

    printBalanced(4);
}


public static void printBalanced(int n){
    String letters = "";

    for(int i =0; i<n/2;i++){
        letters += "ab";
    }


    SortedSet<String> results = balanced("",letters);
    Iterator<String> it = results.iterator();
    while (it.hasNext()) {

        // Get element and print
        Object element = it.next();
        System.out.println(element);
    }

}


//This method returns a SortedSet with permutation results. SortedSet was chosen for its sorting and not allowing
//duplicates properties.
private static SortedSet<String> balanced(String prefix, String s){

    SortedSet<String> set = new TreeSet<String>();

    int len = s.length();

    //base case
    if (len == 0){

        //return the new SortedSet with just the prefix
        set.add(prefix);
        return set;


    }
    else{

        SortedSet<String> rest = new TreeSet<String>();

        for(int i = 0; i<len; i++){

            //get all permutations and store in a SortedSet, rest
            rest = balanced(prefix + s.charAt(i),s.substring(0,i)+s.substring(i+1,len));

            //put each permutation into the new SortedSet
            set.addAll(rest);
        }

        return set;

        }
    }

import java.util.Iterator；
导入java.util.SortedSet；
导入java.util.TreeSet；
公共阶级平衡{
公共静态void main（字符串[]args）{
打印平衡（4）；
}
公共静态无效打印平衡（整数n）{
字符串字母=”；
对于（int i=0；i您可以使用a并将结果存储在其中（最好），这将在遍历时消除重复项并保持排序顺序。
您可以使用最常见的置换实现（将一个元素与第一个元素交换，并置换其余元素）。首先生成字符串，对其排序，然后生成所有可能的排列。不允许重复

一项实施可以是：

static String swap(String s, int i, int j) {
    char [] c = s.toCharArray();
    char tmp = c[i];
    c[i] = c[j];
    c[j] = tmp;
    return String.copyValueOf(c);
}

static void permute(String s, int start) {
    int end = s.length();

    if(start == end) {
        System.out.println(s);
        return;
    }

    permute(s, start + 1);

    for(int i = start + 1; i < end; i++) {
        if(s.charAt(start) == s.charAt(i)) continue;
        s = swap(s, start, i);
        permute(s, start + 1);
    }
}

public static void main(String [] args) {
    String s = "aabb";
    permute(s, 0);
}

此解决方案不需要额外的空间进行排序
学分：

公共类置换{
公共静态无效打印副本（字符串str、字符串前缀）{
如果（str.length（）==0）{
System.out.println（前缀）；
}
否则{
对于（int i=0；i0）{
if（str.charAt（i）=str.charAt（i-1））{
继续；
}
}
打印副本(
str.substring（0，i）+str.substring（i+1，str.length（）），
前缀+str.charAt（一）
); 
}
}
}
公共字符串排序（字符串str）{
//请实现排序功能，我懒得这么做
}
公共静态void main（字符串[]args）{
字符串测试=“asdadsa”；
测试=排序（测试）；
打印副本（测试“”）；
}
}
基于@0605002的代码，我做了一点修改。在permute的for循环中，我们需要在permute方法调用后再次交换。这就像回溯。我们需要将其交换回下一次迭代

static void permute(String s, int start) {
    int end = s.length();

    if(start == end) {
        System.out.println(s);
        return;
    }

    permute(s, start + 1);

    for(int i = start + 1; i < end; i++) {
        if(s.charAt(start) == s.charAt(i)) continue;
        s = swap(s, start, i);
        permute(s, start + 1);
        s = swap(s, start, i);
    }
}

static void permute（字符串s，int start）{
int end=s.length（）；
如果（开始==结束）{
系统输出打印项次；
返回；
}
排列（s，开始+1）；
对于（int i=start+1；i
+1，或者跟踪已打印的内容，不要打印两次相同的内容。如何将递归结果分配给集合或树集合？将集合作为参数传递给方法，添加元素并返回它。谢谢0605002。我已经尝试了您提到的方法，但仍然有相同的副本。
aabb
abab
abba
baab
baba
bbaa

public class Permutation {

    public static void printDuplicates(String str, String prefix) {
        if (str.length() == 0) {
            System.out.println(prefix); 
        }
        else {
            for (int i = 0; i < str.length(); i++) {
                if (i > 0) {
                    if (str.charAt(i) == str.charAt(i - 1)) {
                        continue; 
                    }
                }

                printDuplicates(
                    str.substring(0, i) + str.substring(i + 1, str.length()),
                    prefix + str.charAt(i)
                ); 
            }
        }
    }

    public String sort(string str) {
        // Please Implement the sorting function, I was lazy enough to do so 
    }

    public static void main(String[] args) {
        String test = "asdadsa"; 
        test = sort(test); 
        printDuplicates(test, ""); 
    }
}

static void permute(String s, int start) {
    int end = s.length();

    if(start == end) {
        System.out.println(s);
        return;
    }

    permute(s, start + 1);

    for(int i = start + 1; i < end; i++) {
        if(s.charAt(start) == s.charAt(i)) continue;
        s = swap(s, start, i);
        permute(s, start + 1);
        s = swap(s, start, i);
    }
}