打印一个字符串所有的排列组合！急！急！急！

String input = "abc";    //求a/b/c三个字符的全排列
        Set<String> results = new LinkedHashSet<String>();
        results.add("");
        for (int i=0; i<input.length(); i++)
            for (int j=0; j<input.length(); j++){
                String current = input.substring(j, j+1);
                Set<String> newones = new LinkedHashSet<String>();
                for(String s : results){
                    if (s.indexOf(current)==-1) s+=current;
                    newones.add(s);
                }
                results.addAll(newones);
            }
        for (String s: results)
            if (s.length()==input.length())System.out.println(s);

package test;import java.util.HashSet;
import java.util.Set;/**
* 求 N 个元素的全排列算法:
* 1. 创建一个大小为 N 个元素的数组.
* 2. 利用 N 进制，满 N 加 1的原则，对数组的第0个元素加 1，满 N 了，则下一个元素值加 1.
* 3. 检查数组中的元素是否有重复的，如果没有，则是一个排列.
* 4. 直到数组中的元素为0, 1, 2, ..., N - 1，则结束，否则继续第2步直到结束.
*/
public class Arrangement {
    public static void produceArrangement(String str) {
        int[] digit = new int[str.length()];
        int base = str.length();

        while (!end(digit)) {
            ++digit[0]; // 第1个元素值加1

            // 满N进1
            for (int i = 0; i < digit.length; ++i) {
                if (digit[i] == base) {
                    digit[i] = 0;
                    ++digit[i + 1];
                } else {
                    break;
                }
            }

            if (isArrangement(digit)) {
                printArrangement(str, digit);
            }
        }
    }

    // 数组中每个元素都不同，则是排列中的一个
    private static boolean isArrangement(int[] digit) {
        int sum = 0;
        int endSum = (0 + digit.length - 1) * digit.length / 2;

        for (int i = 0; i < digit.length; ++i) {
            sum += digit[i];
        }

        // 为了减少创建Set，所以判断一下数组中元素的和是不是结束时元素的和，如果是才再继续判断.
        if (sum != endSum) {
            return false;
        } else {
            Set<Integer> is = new HashSet<Integer>();
            for (int i : digit) {
                is.add(i);
            }

            if (is.size() != digit.length) {
                return false;
            } else {
                return true;
            }
        }
    }

    private static void printArrangement(String str, int[] digit) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < digit.length; ++i) {
            sb.append(str.charAt(digit[i]));
        }

        System.out.println(sb);
    }    // 如果数组中的元素是 0, 1, 2, ..., digit.length - 1，则结束
    private static boolean end(int[] digit) {
        for (int i = 0; i < digit.length; ++i) {
            if (digit[i] != i) {
                return false;
            }
        }

        return true;
    }

    public static void main(String[] args) {
        Arrangement.produceArrangement("012345");
    }
}package test;/**
* 求 N 个元素的全排列算法:
* 1. 创建一个大小为 N 个元素的数组.
* 2. 利用 N 进制，满 N 加 1的原则，对数组的第0个元素加 1，满 N 了，则下一个元素值加 1.
* 3. 检查数组中的元素是否有重复的，如果没有，则是一个排列.
* 4. 直到数组中的元素为0, 1, 2, ..., N - 1，则结束，否则继续第2步直到结束.
*//**
* 求 N 个元素中 M 个元素的组合算法:
* 1. 创建一个大小为 N 个元素的数组，前 M 个元素为1，后面的 N-M 个元素为0
* 2. 从左向右找到 10 的元素(前一个元素是1，下一个元素是0), 交换这两个元素；
*    把此元素前面的所有1都移动到数组的最前面，此为一个组合，输出.
* 3. 直到前 N-M 个元素都为0，则结束，否则继续第2步直到结束.
*/
public class Combinatory {
    public static void produceCombination(String str, int size) {
        if (size > str.length()) { throw new IllegalArgumentException("Size is to large."); }        // 创建一个数组，前size个元素全是1
        int[] digit = new int[str.length()];
        for (int i = 0; i < size; ++i) {
            digit[i] = 1;
        }        // 输出第一组
        printCombination(str, digit);        while (!end(digit, digit.length - size)) {
            for (int i = 0; i < digit.length - 1; ++i) {
                if (digit[i] == 1 && digit[i + 1] == 0) {
                    // i上是1，i + 1是0，交换
                    int temp = digit[i];
                    digit[i] = digit[i + 1];
                    digit[i + 1] = temp;                    // 移动i前面的所有1到最左端
                    int count = countOf1(digit, i);
                    for (int j = 0; j < count; ++j) {
                        digit[j] = 1;
                    }                    for (int j = count; j < i; ++j) {
                        digit[j] = 0;
                    }                    printCombination(str, digit);                    break;
                }
            }
        }
    }    // 在下标end前1的个数
    private static int countOf1(int[] digit, int end) {
        int count = 0;
        for (int i = 0; i < end; ++i) {
            if (digit[i] == 1) {
                ++count;
            }
        }        return count;
    }    // 数组中为1的下标对应的字符需要输出
    private static void printCombination(String str, int[] digit) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < digit.length; ++i) {
            if (digit[i] == 1) {
                sb.append(str.charAt(i));
            }
        }        System.out.println(sb);
    }    // 结束条件：前 size 个元素都是0
    private static boolean end(int[] digit, int size) {
        int sum = 0;        for (int i = 0; i < size; ++i) {
            sum += digit[i];
        }        return sum == 0 ? true : false;
    }    public static void main(String[] args) {
        Combinatory.produceCombination("0123456789", 8);
    }
}

http://topic.csdn.net/u/20101217/19/c0708f17-dde8-4c63-981a-465f91a4bdc5.html
我的答案在这贴的3楼嗯

http://blog.csdn.net/barryhappy/archive/2010/12/18/6083455.aspx最近做了

1 楼好久不见啊忙啥呢
private static void comCombination(int[] arr, int index) {
if (index == arr.length - 1) {
for (int i = 0; i < arr.length; i++) {
System.out.printf("%d ",arr[i]);
}
System.out.println();
return;
}
comCombination(arr, index + 1);
for (int i = index + 1; i < arr.length; i++) {
arr[index] ^= arr[i];
arr[i] ^= arr[index];
arr[index] ^= arr[i];
comCombination(arr, index + 1);
arr[index] ^= arr[i];
arr[i] ^= arr[index];
arr[index] ^= arr[i];
}
}

我在楼上少发了些这里补上public static void combination(int[] arr){
comCombination(arr, 0);
}

private static void comCombination(int[] arr, int index) {
if (index == arr.length - 1) {
for (int i = 0; i < arr.length; i++) {
System.out.printf("%d ",arr[i]);
}
System.out.println();
return;
}
comCombination(arr, index + 1);
for (int i = index + 1; i < arr.length; i++) {
arr[index] ^= arr[i];
arr[i] ^= arr[index];
arr[index] ^= arr[i];
comCombination(arr, index + 1);
arr[index] ^= arr[i];
arr[i] ^= arr[index];
arr[index] ^= arr[i];
}
}

楼主需要的是字符串下边这个改了下public class Combination { public static void main(String[] args) {
String str = "abcd";
combination(str);
} public static void combination(String str){
char[] arr = str.toCharArray();
comCombination(arr, 0);
}
private static void comCombination(char[] arr, int index) {
if (index == arr.length - 1) {
for (int i = 0; i < arr.length; i++) {
System.out.printf("%c ",arr[i]);
}
System.out.println();
return;
}
comCombination(arr, index + 1);
for (int i = index + 1; i < arr.length; i++) {
arr[index] ^= arr[i];
arr[i] ^= arr[index];
arr[index] ^= arr[i];
comCombination(arr, index + 1);
arr[index] ^= arr[i];
arr[i] ^= arr[index];
arr[index] ^= arr[i];
}
}}

调试易

打印一个字符串所有的排列组合！急！急！急！

解决方案 »