数字序列“123456”，输出它们所有的排列组合

求一个简单易懂的代码 要说明思路

谭立文 发表于 2012-10-11 17:42
现在大三啊、

那木有办法了，呵呵

刘蕴学 发表于 2012-10-11 17:30
你咋会没进来。。。。

现在大三啊、

谭立文 发表于 2012-10-11 16:30
package com.wenfengkeji.heima;

public class Demo17 {

你咋会没进来。。。。

这个都要用到迭代函数。

谭立文 发表于 2012-10-11 16:30
package com.wenfengkeji.heima;

public class Demo17 {

1. public class Demo17 {
   
2.         public static void perm(char[] a, int k, int n) {
   
3.                 int i;
   
4.                 if (k == n - 1) {
   
5.                         for (i = 0; i < n; i++)
   
6.                                 System.out.print(a[i] + " ");
   
7.                         System.out.println();
   
8.                 } else {
   
9.                         perm(a, k + 1, n);
   
10.                         for (i = k + 1; i < n; i++) {
    
11.                                 a[i] ^= a[k] ^ (a[k] = a[i]);
    
12.                                 perm(a, k + 1, n);
    
13.                                 a[i] ^= a[k] ^ (a[k] = a[i]);
    
14.                         }
    
15.                 }
    
16.         }
    
17. 
    
18.         public static void main(String[] args) {
    
19.                 char ch[] = { '6', '7', '9', '5' };
    
20.                 perm(ch, 0, ch.length);
    
21.         }
    
22. }

复制代码

呵呵……牛，给你个建议你看看改成这样如何

1. import java.util.ArrayList;
   
2. import java.util.List;
   
3. 
   
4. public class GetString {
   
5. 
   
6.         /**
   
7.          * @param args
   
8.          */
   
9.         public static void main(String[] args) {
   
10.                 //把 str 改成 123456 就是你要的结果了
    
11.                 String str="123";
    
12.                 char c[]=str.toCharArray();
    
13.                 //待取出的数据集
    
14.                 List<String> src=new ArrayList<String>();
    
15.                 //储存取出数据的结果集
    
16.                 List<String> obj=new ArrayList<String>();
    
17.                 for(int i=0;i<c.length;i++){
    
18.                         src.add(String.valueOf(c[i]));
    
19.                         obj.add(String.valueOf(0));
    
20.                 }
    
21.                
    
22.                 //采用递归的方式
    
23.                 getChar(src, obj, src.size());
    
24.                
    
25. 
    
26.         }
    
27.         
    
28.         public static void getChar(List<String> src,List<String> obj,int length){;
    
29.                 //如果 待取出的数据集中有数据 继续填充 否则打印 结果集
    
30.                 if(src.size()>0){
    
31.                         for(int i=0;i<src.size();i++){
    
32.                                 obj.set(length-src.size(),src.get(i));
    
33.                                 
    
34.                                 //定义临时变量 传递给下一次 调用
    
35.                                 List<String> tmpsrc=new ArrayList<String>();
    
36.                                 for(int k=0;k<src.size();k++){
    
37.                                         tmpsrc.add(src.get(k));
    
38.                                 }
    
39.                                 //移除已经使用的元素
    
40.                                 tmpsrc.remove(i);
    
41.                                 
    
42.                                 //定义临时变量 传递给下一次 调用
    
43.                                 List<String> tmpobj=new ArrayList<String>();
    
44.                                 for(int k=0;k<obj.size();k++){
    
45.                                         tmpobj.add(obj.get(k));
    
46.                                 }
    
47.                                 //递归 直到src 中没有数据
    
48.                                 getChar(tmpsrc, tmpobj, length);
    
49.                         }        
    
50.                 }else{
    
51.                         System.out.println(obj);
    
52.                 }
    
53.                
    
54.         }
    
55. 
    
56. }

复制代码

结果：[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]

package com.wenfengkeji.heima;

public class Demo17 {
        public static void perm(char[] a,int k,int n)
        {
                int i;
                if(k == n-1)
                {
                        for(i=0;i<n;i++)
                                System.out.print(a[i] + " ");
                        System.out.println();
                }
                else
                {
                        for(i=k;i<n;i++)
                        {
                                char temp;
                                temp=a[k];
                                a[k]=a[i];
                                a[i]=temp;
                                perm(a,k+1,n);
                                temp=a[k];
                                a[k]=a[i];
                                a[i]=temp;
                        }
                }
        }
        public static void main(String[] args) {
                char ch[]={'1','2','3','4','5','6'};
                perm(ch,0,ch.length);
        }
}

1. public class Rank {
   
2.         public static void main(String[] args) {
   
3.                 int[] array = { 7, 9, 5, 8 };// 初始化一个由多个数组成的序列
   
4.                 boolean[] isSelected = new boolean[array.length];// 为每一个数指定一个标志，标志这个数是否在已经在新的序列中
   
5.                 int[] array2 = new int[array.length];// 新的组合序列
   
6.                 for (int i = 0; i < isSelected.length; i++) {
   
7.                         isSelected[i] = false;// 每个数所对应的标志初始化为false
   
8.                 }
   
9.                 rankArray(array, isSelected, array2, 0);
   
10.         }
    
11. 
    
12.         public static void rankArray(int[] array, boolean[] isSelected,
    
13.                         int[] array2, int length) {
    
14. 
    
15.                 if (array.length == length) {
    
16.                         /* 如果初化序列中的数全部排入了新的组合序列中就将它们全部打印出来 */
    
17.                         for (int i : array2) {
    
18.                                 System.out.print(i + ",");
    
19.                         }
    
20.                         System.out.println();
    
21.                         return;
    
22.                 }
    
23.                 for (int i = 0; i < isSelected.length; i++) {
    
24.                         if (isSelected[i]) {
    
25.                                 continue;// 初始序列中的数已经排入了当前这个正在排的新组合序列中，就去找下一个数
    
26.                         }
    
27.                         isSelected[i] = true;// 找到这个未排入当前正在排的新序列中的数后就将与这个数所对应的标志改为true
    
28.                         array2[length] = array[i];// 将这个数排入当前现在排的序列中
    
29.                         rankArray(array, isSelected, array2, length + 1);// 递归，排下一个数
    
30.                         isSelected[i] = false;// 每一次递归结束就得到一个新的序列，然后又开始排第二个新的序列，所以它们的标志又改为false
    
31.                 }
    
32.         }
    
33. }

复制代码

面试宝典我还没看的，不晓得我这个算法和里面的哪个更让人懂
以前在14期别人也问了这样的问题的，当时编了没写注释就贴上去了，今天就把注释加上了

Jordon 发表于 2012-10-11 15:18
因为不方便写代码，我只说一下我的理解：每个数字相当于一个坑，即有六个坑，每个坑里每次放一个数字，但不 ...

那怎么保证放六次 每次放的都不一样 而且后面的坑不会和前面的重复呢

因为不方便写代码，我只说一下我的理解：每个数字相当于一个坑，即有六个坑，每个坑里每次放一个数字，但不能重复。也就是每个坑里放六次数字，放完了就排完了。

面试宝典那个代码没看懂啊 主要是不懂思路 求高手解