哪位大神赐教一下：有一个函数void printArray(char[] arr, int n);
char[] chs = {'a', 'b', 'c', 'd', 'e'};
执行printArray(chs, 1);时输出：a b c d e
执行printArray(chs, 2);时输出：ab ac ad ae bc bd be cd ce de
执行printArray(chs, 3);时输出：abc abd abe acd ace ade bcd bce bde cde
.......
执行printArray(chs, 5);时输出：abcde
这个函数怎么实现。

全排列！！！ 不过数据大的话时间很容易爆

确实是全排列。。。。
根据排列组合的范围，数据较多的时候运算次数会很大。。
用递归吧...

这个题哪里的？看到第三回类似的了。

这是很死板的方式，没有扩展性，刚看到LS们的建议，想想用递归什么的怎么搞，O(∩_∩)O~

package hehe;
class PrintDemo
{
        public static void main(String[] args)
        {
                char[] chs = {'a', 'b', 'c', 'd', 'e'};
                printArray(chs, 1);                //时输出：a b c d e
                sop("————————————————");
                printArray(chs, 2);                //时输出：ab ac ad ae bc bd be cd ce de
                sop("————————————————");
                printArray(chs, 3);                //时输出：abc abd abe acd ace ade bcd bce bde cde
                sop("————————————————");
                printArray(chs, 4);
                sop("————————————————");
                printArray(chs, 5);                //时输出：abcde

        }
        public static void printArray(char[] arr, int n)
        {
                for(int a=0;a<arr.length;a++)
                {
                        if(n==1)                        //打印n=1时的排列情况；
                                sop(arr[a]);
                        for(int b=0;b<arr.length;b++)
                        {
                               if(n==2)                        //打印n=2时的排列情况；
                                {
                                        if(a>=b)
                                                continue;
                                        else
                                                sop(arr[a]+""+arr);
                                }
                                for(int c=0;c<arr.length;c++)
                                {
                                        if(n==3)                //打印n=3时的排列情况；
                                        {
                                                if(a>=b | b>=c)
                                                        continue;
                                                else
                                                        sop(arr[a]+""+arr+""+arr[c]);
                                        }
                                        for(int d=0;d<arr.length;d++)
                                        {
                                                if(n==4)                //打印n=4时的排列情况；
                                                {
                                                        if(a>=b | b>=c | c>=d)
                                                                continue;
                                                        else
                                                                sop(arr[a]+""+arr+""+arr[c]+""+arr[d]);
                                                }
                                                for(int e=0;e<arr.length;e++)
                                                {
                                                       if(n==5)                //打印n=5时的排列情况；
                                                        {
                                                                if(a>=b | b>=c | c>=d | d>=e)
                                                                        continue;
                                                                else
                                                                        sop(arr[a]+""+arr+""+arr[c]+""+arr[d]+""+arr[e]);
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
}

zms2100 发表于 2013-5-10 12:54
这是很死板的方式，没有扩展性，刚看到LS们的建议，想想用递归什么的怎么搞，O(∩_∩)O~

package hehe;

这个函数看来很难，一般人做不出来啊！

long 发表于 2013-5-10 12:58
这个函数看来很难，一般人做不出来啊！

这个函数你会打印出int n <= 3 的情况，你就会后面的了，基本上都是重复的（之后每次都是添加新的参数但是是重复功能）。
（我编辑下，给你看看颜色，区分）

下面的可以任意指定字符数组，任意指定数字。这个用的不是递归的方法。

1.         /**
   
2.         获取获取所给字符数组中元素组成的组合。
   
3.         例如：给的是{'a','b','c','d'}那么得到的就是a,b,c,ab,ac,,ad,bc,,bd,abc,abd,acd,bcd,abcd
   
4.         */
   
5.         private static ArrayList<String> zuHe(char[] ch) {
   
6.                 ArrayList<String> ts = new ArrayList<String>();
   
7.                 /**
   
8.                         数组jishu是用来记录每一个字符串的最后一个字符的在字符数组中的坐标，
   
9.                         指明下一次这个字符串应该从哪个坐标开始和字符数组中的元素进行加运算。
   
10.                         例如：对于字符串”ab",它记录的是1，那么就知道“ab"下一次应该从1+1号下标
    
11.                         开始进行加运算。
    
12.                 */
    
13.                 int[] jishu = new int[ch.length*(ch.length-1)];
    
14.                 int[] jiu = new int[ch.length*(ch.length-1)];
    
15.                 int xia = 0;
    
16.                 for(int x = 0;x<ch.length;x++)
    
17.                 {
    
18.                         ts.add(ch[x]+"");
    
19.                         jishu[xia++] = x;
    
20.                 }
    
21.                 fu(jishu,jiu);
    
22.                 int i = 1,num = ts.size(),shu = ts.size();
    
23.                 int y;
    
24.                 while(i<ch.length){
    
25.                         int y1 = num-shu;
    
26.                         for(y=num-shu,shu =0,xia =0;y<num;y++){
    
27.                                 /**
    
28.                                 y每增加一次，就代表着1个新的字符串开始进行加运算，                               
    
29.                                 */
    
30.                                 for(int x = jiu[y-y1]+1;x<ch.length;x++){
    
31.                                         ts.add(ts.get(y)+ch[x]);
    
32.                                         jishu[xia++]=x;//记录下标。
    
33.                                         shu++;
    
34.                                 }
    
35.                         }
    
36.                         num = ts.size();
    
37.                         i++;
    
38.                         fu(jishu,jiu);
    
39.                 }
    
40.                         return ts;
    
41.         }
    
42.         private static void fu(int[] jishu,int[] jiu)//赋值,但不让后者指向前者。
    
43.         {
    
44.                 for(int x=0;x<jishu.length;x++){
    
45.                         jiu[x]=jishu[x];
    
46.                 }
    
47.         }
    
48.         //获取指定字符个数的字符串。
    
49.         private static ArrayList<String> onlyN(char[] ch,int n)
    
50.         {
    
51.                 ArrayList<String> als = new ArrayList<String>();
    
52.                 ArrayList<String> als1 = zuHe(ch);
    
53.                 for(String al:als1)
    
54.                 {
    
55.                         if(al.length() == n)
    
56.                                 als.add(al);
    
57.                 }
    
58.                 return als;
    
59.         }

复制代码

如果问题已解决，请及时修改分类，否则继续提问，谢谢合作！