编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符
例如：
原始字符串是"abc"，打印得到下列所有组合情况
"a" "b" "c"
"ab" "bc" "ca" "ba" "cb" "ac"
"abc" "acb" "bac" "bca" "cab" "cba"。:dizzy:多一点代码注释，本人好分析理解，非常感谢！

public class Test{

        public static void main(String[] args) {
               
                String s ="abc";
                char[] arr = s.toCharArray();
                new Test().Sort(arr);
        }
        //排列
        public static void Sort(char[] arr)
        {
                //输出第一行
                for(int i = 0;i<arr.length;i++)
                {
                        System.out.print("\""+arr[i]+"\"");
                }
                System.out.println();
                //输出第二行
                for(int i = 0;i<arr.length;i++)
                {
                        for(int j = 0;j<arr.length;j++)
                        {
                                if(arr[i]!=arr[j])
                                System.out.print("\""+arr[i]+arr[j]+"\"");
                        }
                }
                System.out.println();
                //输出第三行
                for(int i = 0;i<arr.length;i++)
                {
                        for(int j = 0;j<arr.length;j++)
                        {
                                for(int k = 0;k<arr.length;k++)
                                if(arr[i]!=arr[j]&&arr[i]!=arr[k]&&arr[j]!=arr[k])
                                System.out.print("\""+arr[i]+arr[j]+arr[k]+"\"");
                        }
                }
                System.out.println();
               
       
        }
}

我的这个代码有点局限性不能拓展，只能是三个字符，要各种字符的话，估计要用到递归，我完了再试试

1. public class StringDemo {
   
2.         public static void main(String[] args) {
   
3.                 String string = "abc";
   
4.                 char[] charArray = string.toCharArray();
   
5.                 for (int i = 0; i < charArray.length; i++) {
   
6.                         //一个字符
   
7.                         System.out.println(charArray[i]);
   
8.                         //两个字符
   
9.                         for (int j = 0; j < charArray.length; j++) {
   
10.                                 if(charArray[j] != charArray[i]) {
    
11.                                         System.out.println(charArray[i] + "" +charArray[j] + "");
    
12.                                         //三个字符
    
13.                                         for (int k = 0; k < charArray.length; k++) {
    
14.                                                 if(charArray[k] != charArray[j] && charArray[k] != charArray[i])
    
15.                                                 System.out.println(charArray[i] + "" + charArray[j] + "" + charArray[k] + "");
    
16.                                         }
    
17.                                 }
    
18.                         }
    
19.                 }
    
20.         }
    
21. }

复制代码

楼上，我觉得你这种方法空间复杂度过高，如果26个字母全部出现的话空间将占用极大，你不觉得这样会内存溢出吗？而且不一定就只有3位呀，你这个char数组不能确定开几维呀，只能按最大开，那就要建立一个26x26的char数组。这样不大合适吧，我觉得还是全排列好一点。楼主看看有什么启发
PS： 全排列代码

1. public class AllSort {
   
2.         public static void main(String[] args) {
   
3.                 char buf[] = { 'a', 'b', 'c' };
   
4.                 perm(buf, 0, buf.length - 1);
   
5.         }
   
6. 
   
7.         public static void perm(char[] buf, int start, int end) {
   
8.                 if (start == end) {
   
9.                         for (int i = 0; i <= end; i++) {
   
10.                                 System.out.print(buf[i]);
    
11.                         }
    
12.                         System.out.print("  ");
    
13.                 } else {
    
14.                         for (int i = start; i <= end; i++) {// （让指针start分别指向每一个数）
    
15.                                 char temp = buf[start];// 交换数组第一个元素与后续的元素
    
16.                                 buf[start] = buf[i];
    
17.                                 buf[i] = temp;
    
18. 
    
19.                                 perm(buf, start + 1, end);// 后续元素递归全排列
    
20. 
    
21.                                 temp = buf[start];// 将交换后的数组还原
    
22.                                 buf[start] = buf[i];
    
23.                                 buf[i] = temp;
    
24.                         }
    
25.                 }
    
26.         }
    
27. }

复制代码

希望能帮到你：

1. import java.util.Scanner;
   
2. public class PaiLie
   
3. {
   
4. 
   
5.     private int len;
   
6.     private char[] getRest(char[] arr,int i)
   
7.     {
   
8.             char[] rs=new char[arr.length-1];
   
9.             for(int j=0;j<i;j++)
   
10.                 rs[j]=arr[j];
    
11.             for(int j=i+1;j<arr.length;j++)
    
12.                 rs[j-1]=arr[j];
    
13.             return rs;
    
14.     }
    
15.    
    
16.     public void getResult_All(String content)
    
17.     {
    
18.             char[] arr=content.toCharArray();
    
19.             len=arr.length;
    
20.             PL_All("",arr,len);
    
21.    
    
22.     }
    
23.     private void swap(char[] arr,int i,int j)
    
24.     {
    
25.         if(i==j)
    
26.             return;
    
27.         char tmp=arr[i];
    
28.         arr[i]=arr[j];
    
29.         arr[j]=tmp;
    
30.         }
    
31.     private void PL_All(String pre,char[] arr,int length)
    
32.     {
    
33.         if(length<1)
    
34.                 return;
    
35.         
    
36.         for(int i=0;i<length;i++)
    
37.         {
    
38.                 char first=arr[i];
    
39.                 swap(arr, i, length-1);
    
40.                 PL_All(pre+first,arr,length-1);
    
41.                 swap(arr, length-1,i);
    
42.         }
    
43.     }
    
44.    
    
45.     public static void main(String[] args)
    
46.     {
    
47.                 Scanner scanner=new Scanner(System.in);
    
48.                 System.out.println("please input:");
    
49.                 String content=scanner.nextLine();
    
50. 
    
51. PaiLie  PL=new
    
52. PaiLie ();
    
53.                 PL.getResult_All(content);
    
54.     }
    
55. }

复制代码

薛旻 发表于 2014-3-4 16:41
我的这个代码有点局限性不能拓展，只能是三个字符，要各种字符的话，估计要用到递归，我完了再试试
...

嘿嘿，为了简单，循环嵌在一起了，抱歉抱歉，意思还是可以理解的