编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符,
                例如：原始字符串是"abc"，
                打印得到下列所有组合情况：
                "a" "b" "c"
                "ab" "bc" "ca" "ba" "cb" "ac"
                "abc" "acb" "bac" "bca" "cab" "cba"

这都不会。。。

hm1314 发表于 2014-6-23 08:42
楼上正解。

虽然解决，但是做法明显太烂:'(

辉辉啊辉辉，其实我也没做出来！

我来学习了！~~~~~~~~~

这道题是哪里来的?

苏周周 发表于 2014-6-22 00:49
用的是递归

我看过第10期的论坛，也有人提问类似的 问题，但很少有人答出来

楼上正解。

package com.itheima;

public class test {

        public static void main(String[] args) {
                String str ="abcd";
                //将字符串转为字符数组
                char[] cs =str.toCharArray();
                String[] strs=new String[cs.length];
                for(int i=0;i<cs.length;i++){
                        strs[i]=new Character(cs[i]).toString() ;
                        System.out.print(strs[i]+" ");
                }
                System.out.println("\t");
                String[] newStrs = combination(strs,strs);
                for(int i =0;i<str.length()-2;i++){
                        newStrs = combination(strs,newStrs);
                }
        }
       
        public static String[] combination(String[] s1,String[] s2){
                String[] strs = new String[s1.length*s2.length];
                int len = 0;
                for(int i=0;i<s1.length;i++){
                        for(int j=0;j<s2.length;j++){
                                if(s2[j].indexOf(s1[i])==-1){
                                        System.out.print(s1[i]+s2[j]+" ");
                                        strs[len]=s1[i]+s2[j];
                                        len++;
                                }       
                        }
                }
                System.out.println("\t");
                String[] newStrs = new String[len];
                for(int i=0;i<len;i++){
                        newStrs[i]=strs[i];
                }
                return newStrs;
        }

}

用的是递归


import java.util.Scanner;
import java.util.TreeSet;

public class Test07 {
        public static void main(String[] args) {
                // 定义一个键盘输入
                System.out.println("输入一个字符串：");
                Scanner sc = new Scanner(System.in);

                String string = sc.next();
                System.out.println(string);

                sc.close();
                show(string);
        }

        // 打印字符串的所有可能的组合
        private static void show(String str) {
                TreeSet<String> set = saveInSet(new StringBuilder(str), 0,
                                new StringBuilder(), new TreeSet<String>());
                for (String s : set) {
                        System.out.println(s);
                }
        }

        /**
         * 返回集合，集合包含字符串所有字符的可能组合
         *
         * @param str
         *            给定字符串转换成的StringBuilder对象，主要是为了操作字符方便
         * @param count
         *            计数，对第count进行排列组合
         * @param buff
         *            暂存放某种可能
         * @param set
         *            集合，去除重复元素，例如"aab"以第一个a开头会有aba，以第二个a开头也会有aba
         * @return 返回TreeSet集合
         */
        private static TreeSet<String> saveInSet(StringBuilder str, int count,
                        StringBuilder buff, TreeSet<String> set) {
                for (int x = 0, len = str.length(); x < len; x++) {
                        // 获取字符
                        char ch = str.charAt(x);
                        // 去掉原字符串的某个字符（保证某个字符不被重复利用）
                        str.deleteCharAt(x);
                        // 缓存添加该字符
                        buff.append(ch);
                        // 将该种可能组合存入集合
                        set.add(buff.toString());
                        // str仍包含字符，则递归调用，开始取第二位字符
                        // 若还有第三位则继续递归……以此类推
                        if (str.length() != 0) {
                                // count用于记录目前在进行排列组合的第count位
                                count++;
                                // 递归
                                saveInSet(str, count, buff, set);
                                // 第n位递归结束后，需要继续对n-1位排列，位数-1
                                count--;
                        }

                        // 递归结束后，需要继续对n-1位排列，因此清除第n位的记录
                        buff.deleteCharAt(count);
                        // 删除的字符插回str
                        str.insert(x, ch);
                }
                // 返回集合
                return set;

        }

}

最好带注释的 ，谢谢了