给定一个不确定长度的数组例如：int[] arr = {a,b,c,d...};把数组中的元素排列组合去掉重复元素打印出来
打印出来的个数是2^n-1(n是数组的长度)不准调用函数要过程

恕我无知2^n-1(n是数组的长度)是什么意思...^是异或么...?

{:soso_e110:}^是幂运算吧

1. import java.util.Arrays;
   
2. import java.util.Random;
   
3. 
   
4. public class Example14 {
   
5. 
   
6.         /**int[] arr = {a,b,c,d...};去掉重复元素
   
7.          * @param args
   
8.          */
   
9.         public static void main(String[] args) {
   
10.                 printArray(getArray(50,10));//因为是数组,所以不是数字,就是字符串或其他的东西.数据都是一类的
    
11.         }
    
12.         /**
    
13.          * n是数组的长度,max生成最大可能数
    
14.          */
    
15.         public static int[] getArray(int n,int max){
    
16.                 int[] arr=new int[n];
    
17.                 Random rand=new Random();
    
18.                 for(int i=0;i<n;i++){
    
19.                         arr[i]=rand.nextInt(max)+1;
    
20.                 }
    
21.                 System.out.println("原始数组:"+Arrays.toString(arr));
    
22.                 return arr;
    
23.         }
    
24.         public static void printArray(int...arr){
    
25.                 int[] temp=new int[arr.length];
    
26.                 int count=0;
    
27.                 for(int i=0,j=0;i<arr.length;i++){
    
28.                         if(getResult(temp,arr[i])){
    
29.                                 temp[j++]=arr[i];
    
30.                                 count++;
    
31.                         }
    
32.                 }
    
33.                 int[] newArr = new int[count];
    
34. //                System.arraycopy(newArr,0,count,arr,arr.length);
    
35.                 for(int i=0;i<count;i++)
    
36.                         newArr[i]=temp[i];
    
37.                 System.out.println("最后的数组:"+Arrays.toString(temp));
    
38.                 System.out.println("掉零后数组:"+Arrays.toString(newArr));
    
39.         }
    
40.         public static boolean getResult(int[] arr,int num){
    
41.                 for(int i=0;i<arr.length;i++){
    
42.                        
    
43.                         if(arr[i]==0)//提高效率
    
44.                                 break;
    
45.                         else if(num==arr[i])
    
46.                                 return false;
    
47.                 }
    
48.                 return true;
    
49.         }
    
50. }
    

复制代码

陈圳 发表于 2013-5-9 17:01
恕我无知2^n-1(n是数组的长度)是什么意思...^是异或么...?

是2的n次幂减一

排列组合除掉重复元素是什么意思？如果把数组中的重复元素除掉的话就输出不了2^n-1个了啊。另外你到底要输出的是排列还是组合？这是两个概念。排列是讲顺序的，组合是没有顺序的。

飞鸟青崖 发表于 2013-5-9 19:10
排列组合除掉重复元素是什么意思？如果把数组中的重复元素除掉的话就输出不了2^n-1个了啊。另外你到底要输 ...

组合。排列先不用管要是能打印出排列更好

陈圳 发表于 2013-5-9 18:02

同学，昨天的题可能没说明白。应该是给定一个不确定长度的数组，例如char[]  arr=new char{'a','b','c','d'};
要将里面的元素重新排列组合成a,b,c,d,ab,ac,ad,bc,bd,cd,abc,abd,acd,bcd,abcd。数组长度为几，答应输出的结果长度就为2^n-1个。其中不能调用系统特殊函数，要求过程，可以使用自己定义的函数。

HM刘志朋 发表于 2013-5-9 19:35
同学，昨天的题可能没说明白。应该是给定一个不确定长度的数组，例如char[]  arr=new char{'a','b','c',' ...

这个很好做出来,但是与你主题说的,完全没有关系的.等下我写下.然后把代码给你.

陈圳 发表于 2013-5-9 19:45
这个很好做出来,但是与你主题说的,完全没有关系的.等下我写下.然后把代码给你. ...

呵呵  谢了

HM刘志朋 发表于 2013-5-9 19:49
呵呵  谢了

方式有点傻B啊,不要笑啊.

1. public class Example15 {
   
2. 
   
3.         /**应该是给定一个不确定长度的数组，例如char[]  arr=new char{'a','b','c','d'};
   
4.              要将里面的元素重新排列组合成a,b,c,d,ab,ac,ad,bc,bd,cd,abc,abd,acd,bcd,abcd
   
5.          * @param args
   
6.          */
   
7.         public static void main(String[] args) {
   
8. //                printAssemble1('a','b','c','d');
   
9.                 printAccemble2('a','b','c','d');
   
10.         }
    
11.         public static void printAccemble2(char...arr){
    
12.                 StringBuilder builder=new StringBuilder();
    
13.                 for(int i=0;i<arr.length;i++)//a,b,c,d
    
14.                         builder.append(arr[i]+" ");
    
15.                 int begin=0,end=1,n=1,length=arr.length-1;
    
16.                 while(begin!=length){
    
17.                         for(int i=begin;i<=end;i+=(end-begin)){//打印ab,ac,ad,
    
18.                                 builder.append(arr[i]);
    
19.                         }
    
20.                         builder.append(" ");
    
21.                         if(end==length){//end==3,2,3
    
22.                                 begin++;end=++n;
    
23.                         } else {
    
24.                                 end++;
    
25.                         }
    
26.                 }
    
27.                 end=length;
    
28.                 while(end!=-2){
    
29.                         for(int i=0;i<length+1;i++){
    
30.                                 if(i!=end)
    
31.                                         builder.append(arr[i]);
    
32.                         }
    
33.                         end--;
    
34.                         builder.append(" ");
    
35.                 }
    
36.                 System.out.println(builder.toString());
    
37.         }
    
38. }
    
39. //改一改可以做到通用性,但是这个应该不具备.我开始做的时候没有分析.瞎编了很多,浪费了很多时间,后面拿纸画了画,就容易做出来了...

复制代码

//打印结果:a b c d ab ac ad bc bd cd abc abd acd bcd abcd

1. /*
   
2. 示例：
   
3. char[] arr = {a,b,c,d};
   
4. 输出：a,b,c,d,ab,ac,ad,bc,bd,cd,abc,abd,acd,bcd,abcd
   
5. 如果数组中是5个不相同的元素再重新排列输出
   
6. */
   
7. class ForMianShi
   
8. {
   
9.         public static void main(String[] args)
   
10.         {
    
11.                 char[] arr = {'a','b','c','d'};
    
12.                 PaiLie(arr);
    
13.         }
    
14.         public static void PaiLie(char[] arr)
    
15.     {
    
16.                 String s = "";
    
17.                 for (int x=0;x<arr.length ;x++ )//a  b
    
18.                 {
    
19.                         System.out.println(s+arr[x]);//a  b
    
20.                         for (int y=1+x;y<arr.length ;y++ )
    
21.                         {
    
22.                                 System.out.println(s+arr[x]+arr[y]);//ab  ac   
    
23.                                
    
24.                                 for (int z=y+1;z<arr.length ;z++ )//c
    
25.                                 {
    
26.                                         System.out.println(s+arr[x]+arr[y]+arr[z]);//abc
    
27.                                        
    
28.                                         for (int i=z+1;i<arr.length ;i++ )
    
29.                                         {
    
30.                                                 System.out.println(s+arr[x]+arr[y]+arr[z]+arr[i]);
    
31.                                         }
    
32.                                                
    
33.                                 }
    
34.                         }
    
35.                 }
    
36.         }
    
37. }

复制代码

打印结果：

陈圳 发表于 2013-5-9 21:10
方式有点傻B啊,不要笑啊.//打印结果:a b c d ab ac ad bc bd cd abc abd acd bcd abcd

ok 了对了怎么让这个未解决的帖子变成已解决吗？

HM刘志朋 发表于 2013-5-9 22:18
ok 了对了怎么让这个未解决的帖子变成已解决吗？

点帖子下面的编缉.然后选择主题分类.

HM刘志朋 发表于 2013-5-9 22:18
ok 了对了怎么让这个未解决的帖子变成已解决吗？

点帖子下面的编缉.然后选择主题分类.

HM刘博 发表于 2013-5-9 22:05
打印结果：

ok 了
thank you！

这个程序可以指定任意的数组，长度不限。

1. import java.util.ArrayList;
   
2. /**
   
3. 思路：
   
4.         用一个集合存储得到的字符串。假设我们已经取到了所有的三个字符所组成的字符串。
   
5. 如果要得到四个字符所组成的字符串，只需要把所有的三个字符组成的字符串和所给的字符
   
6. 数组中的一部分字符进行“+”运行就行。
   
7. */
   
8. class MyTest {       
   
9.         public static void main(String[] args) {               
   
10.                 char[] ch = {'a','b','c','d','e'};
    
11.                 ArrayList<String> ts = zuHe(ch);
    
12.                 for(String str:ts){
    
13.                         System.out.println(str);
    
14.                 }
    
15.         }
    
16.         /**
    
17.         paiLie()获取所给字符数组中元素组成的排列。和本题无关，但是后一个方法的思路来源于它。
    
18.         例如：给的是{'a','b','c'}那么得到的就是a,b,c,ab,ac,bc,abc.
    
19.         */
    
20.         private static ArrayList<String> paiLie(char[] ch) {
    
21.                 ArrayList<String> ts = new ArrayList<String>();
    
22.                 for(int x = 0;x<ch.length;x++)//向集合中添加元素，这些元素就是所有的由一个字符组成的字符串。
    
23.                 {
    
24.                         ts.add(ch[x]+"");
    
25.                 }
    
26.                 int i = 1,num = ts.size(),shu = ts.size();
    
27.                 /**
    
28.                 shu代表每一次新添加的字符串的个数。
    
29.                 例如：由3个字符的字符串得到4个字符的字符串时，这个shu代表的就是4个字符组成的字符串的个数。
    
30.                 */
    
31.                 int y;//定义在这里，是为了在for循环中定义shu =0               
    
32.                 while(i<ch.length){
    
33.                         for(y=num-shu,shu =0;y<num;y++){
    
34.                                 for(int x = 0;x<ch.length;x++){
    
35.                                         ts.add(ts.get(y)+ch[x]);
    
36.                                         shu++;
    
37.                                 }
    
38.                         }
    
39.                         num = ts.size();
    
40.                         i++;
    
41.                 }
    
42.                         return ts;
    
43.         }
    
44.         /**
    
45.         获取获取所给字符数组中元素组成的组合。
    
46.         例如：给的是{'a','b','c','d'}那么得到的就是a,b,c,ab,ac,,ad,bc,,bd,abc,abd,acd,bcd,abcd
    
47.         */
    
48.         private static ArrayList<String> zuHe(char[] ch) {
    
49.                 ArrayList<String> ts = new ArrayList<String>();
    
50.                 /**
    
51.                         数组jishu是用来记录每一个字符串的最后一个字符的在字符数组中的坐标，
    
52.                         指明下一次这个字符串应该从哪个坐标开始和字符数组中的元素进行加运算。
    
53.                         例如：对于字符串”ab",它记录的是1，那么就知道“ab"下一次应该从1+1号下标
    
54.                         开始进行加运算。
    
55.                 */
    
56.                 int[] jishu = new int[ch.length*(ch.length-1)];
    
57.                 int[] jiu = new int[ch.length*(ch.length-1)];
    
58.                 int xia = 0;
    
59.                 for(int x = 0;x<ch.length;x++)
    
60.                 {
    
61.                         ts.add(ch[x]+"");
    
62.                         jishu[xia++] = x;
    
63.                 }
    
64.                 fu(jishu,jiu);
    
65.                 int i = 1,num = ts.size(),shu = ts.size();
    
66.                 int y;
    
67.                 while(i<ch.length){
    
68.                         int y1 = num-shu;
    
69.                         for(y=num-shu,shu =0,xia =0;y<num;y++){
    
70.                                 /**
    
71.                                 y每增加一次，就代表着1个新的字符串开始进行加运算，                               
    
72.                                 */
    
73.                                 for(int x = jiu[y-y1]+1;x<ch.length;x++){
    
74.                                         ts.add(ts.get(y)+ch[x]);
    
75.                                         jishu[xia++]=x;//记录下标。
    
76.                                         shu++;
    
77.                                 }
    
78.                         }
    
79.                         num = ts.size();
    
80.                         i++;
    
81.                         fu(jishu,jiu);
    
82.                 }
    
83.                         return ts;
    
84.         }
    
85.         private static void fu(int[] jishu,int[] jiu)//赋值,但不让后者指向前者。
    
86.         {
    
87.                 for(int x=0;x<jishu.length;x++){
    
88.                         jiu[x]=jishu[x];
    
89.                 }
    
90.         }
    
91. }
    
92.                        

复制代码

飞鸟青崖 发表于 2013-5-10 00:00
这个程序可以指定任意的数组，长度不限。

非常感谢

陈圳 发表于 2013-5-9 22:27
点帖子下面的编缉.然后选择主题分类.

:L没找到啊，给截个图好吗？谢谢

老师讲过那个符号是异或符号