给定整数n(0<n<10),求1-n的全排列,例如给定3,全排列为123、132、213、231、312、321

就把算法给你写一下：
for(int i = 1;i<=n;i++)
for(int j = 1;j<=n;j++)
for(int k = 1;k<=n;k++)
{
   if(i==j || i==k || j==k)
     continue;
else
  System.out.println(i*100+j*10+k);

}

这样我想应该也可以：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #define maxN 10
   
4. void permutation(int n,int arry[],int Arry_n)
   
5. {
   
6.         if(Arry_n==n)
   
7.         {
   
8.                 int i=0;
   
9.                 for(;i<n;++i)
   
10.                         printf("%d\t",arry[i]);
    
11.                 printf("\n");
    
12.         }
    
13.         int iwhich=1;
    
14.         for(;iwhich<=n;++iwhich)
    
15.         {
    
16.                 bool PDuan_InArry=false;
    
17.                 int temp=0;
    
18.                 for(;temp<Arry_n;++temp)
    
19.                 {
    
20.                         if(iwhich==arry[temp])
    
21.                         {
    
22.                                 PDuan_InArry=true;
    
23.                                 break;
    
24.                         }
    
25.                 }
    
26.                 if(false==PDuan_InArry)
    
27.                 {
    
28.                         arry[Arry_n]=iwhich;
    
29.                         permutation(n,arry,Arry_n+1);
    
30.                 }
    
31.         }
    
32. }
    
33. 
    
34. void main()
    
35. {
    
36.         int arry[maxN]={-1};
    
37.         permutation(maxN,arry,0);
    
38. }

复制代码

这是我的一种实现方法

1. import java.util.TreeSet;
   
2. import java.util.Set;
   
3. 
   
4. 
   
5. public class FullPermutationDemo {
   
6. 
   
7.         /**
   
8.          * @param args
   
9.          * 需求：给定整数n(0<n<10),求1-n的全排列,例如给定3,全排列为123、132、213、231、312、321
   
10.          *
    
11.          * 思路：采用递归的思想，先获得n-1的全排列，再利用n-1的全排列获得n的全排列
    
12.          *
    
13.          * 注：采用TreeSet存储数据是因为其默认实现
    
14.          */
    
15.         public static void main(String[] args) {
    
16.                 // TODO Auto-generated method stub
    
17.                 Set<String> set = fullPermutation(3);
    
18.                 for(String s : set)
    
19.                         System.out.println(s);
    
20.         }
    
21.        
    
22.         public static TreeSet<String> fullPermutation(int n)
    
23.         {
    
24.                 if(n<1||n>9)//指定范围
    
25.                         throw new RuntimeException("必须是大于0并且小于10的整数");
    
26.                 //创建TreeSet，用来存储全排列得到的字符串
    
27.                 TreeSet<String> set = new TreeSet<String>();
    
28.                 if(n==1)//如果n等于1，就将1存入set中
    
29.                         set.add(n+"");
    
30.                 else {
    
31.                         /*
    
32.                          * 如果n不等于1，就先获取n-1的所有全排列类型，然后再每一种n-1全排列的所有位置上
    
33.                          * 插入n，在一个位置上插入一次n就构成一个n的全排列
    
34.                          * 例如：2的全排列类型有12、21，可以看成_1_2_,_2_1_，在每一个下划线的位置上
    
35.                          * 分别放一个3，就构成了所有3的全排列，以此类推
    
36.                          */
    
37.                         TreeSet<String> subSet = fullPermutation(n-1);//获取存储n-1的全排列的TreeSet
    
38.                         for(String s : subSet) {//遍历每一种n-1的全排列类型
    
39.                                 for(int i = 0; i<=s.length(); i++) {
    
40.                                         StringBuilder sb = new StringBuilder(s);//利用s构造StringBuilder，方便插入n
    
41.                                         if(i==s.length())//如果i等于字符串长度，则将n放到最后一个位置，因为在这个位置上不能使用insert，所以必须判断
    
42.                                                 sb.append(n);
    
43.                                         else
    
44.                                                 sb.insert(i, n);//在第i个位置上插入n
    
45.                                         set.add(sb.toString());//获得一种全排列类型并存入TreeSet中
    
46.                                         sb = null;//断开引用，等待垃圾回收
    
47.                                 }
    
48.                         }
    
49.                 }
    
50.                 return set;
    
51.         }
    
52.        
    
53. }
    

复制代码

我采用了递归的方式求这个全组合：

1. import java.util.*;
   
2. 
   
3. public class Num_Seria{
   
4.         public static void main(String[] args){
   
5.                 //从键盘输入0-9 之间的一个数字，在这里偷懒没有对n进行输入检查
   
6.                 System.out.println("请输入0-9之间的一个数字");
   
7.                 Scanner s = new Scanner(System.in);
   
8.                 int n = -1;
   
9.                 if(s.hasNext()){
   
10.                         n = s.nextInt();
    
11.                 }
    
12.                 //将 1  -  n  之间的数字按顺序存入集合 data中
    
13.                 ArrayList<Integer> data = new ArrayList<Integer>();
    
14.                 for(int i = n; i>0; i--){
    
15.                         data.add(new Integer(i));
    
16.                 }
    
17.                 //调用递归方法打印全组合
    
18.                 sort(data, new ArrayList<Integer>(), n);
    
19. 
    
20.         }
    
21. 
    
22.         private static void sort(List<Integer> datas,List<Integer> target, int num) {
    
23.                 //如果临时集合中的元素个数等于num时，表示得到了一个组合，打印该组合
    
24.                 if (target.size() == num) {
    
25.                         for(Integer i : target){
    
26.                                 System.out.print(i);
    
27.                         }
    
28.                         System.out.print("\t");
    
29.                 }
    
30.                 //递归调用
    
31.                 for (int i = 0; i < datas.size(); i++) {
    
32.                         List newDatas = new ArrayList(datas);
    
33.                         List newTarget = new ArrayList(target);
    
34.                         newTarget.add(newDatas.remove(i));
    
35.                         sort(newDatas, newTarget, num);
    
36.                 }
    
37.         }
    
38. }

复制代码

测试通过，可以达到效果

关于全组合的问题，
我在基础测试题中碰到了一个
（主要是测试题提交之后才感觉需要重写，然后重新优化了下代码）

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

1. import java.util.ArrayList;
   
2. import java.util.Arrays;
   
3. import java.util.List;
   
4. import java.util.Scanner;
   
5. public class Test5_pro {
   
6.         public static void main(String[] args) {
   
7.                 Scanner scanner = new Scanner(System.in);
   
8.                 System.out.println("请输入一个长度大于1的字符串：");
   
9.                 if (scanner.hasNext()) {
   
10.                         String str = scanner.next();
    
11.                         if (str != null && str.length() > 1) {
    
12.                                 printAllStr(str);
    
13.                         } else {
    
14.                                 System.out.println("请输入一个长度大于1的字符串：");
    
15.                         }
    
16.                 }
    
17.         }
    
18.         private static void printAllStr(String str) {
    
19.                 ArrayList<String> arrayList = new ArrayList<String>();
    
20.                 char[] chars = str.toCharArray();
    
21.                 List<Character> datas = new ArrayList<Character>();
    
22.                 for(char c : chars){
    
23.                         datas.add(c);
    
24.                 }
    
25.                 for (int i = 1; i <= str.length(); i++) {
    
26.                         sort(datas, new ArrayList<Character>(), i,  arrayList);
    
27.                 }
    
28.                 System.out.println("该字符串的全字符组合：");
    
29.                 int length = 1;
    
30.                 for (String s : arrayList) {
    
31.                         if (s.length() > length) {
    
32.                                 System.out.println();
    
33.                                 length++;
    
34.                         }
    
35.                         System.out.print(s + "\t");
    
36.                 }
    
37.         }
    
38.         private static void sort(List<Character> datas, List<Character> target,
    
39.                         int num, ArrayList<String> arrayList) {
    
40.                 if (target.size() == num) {
    
41.                         char[] tmpCs = new char[num];
    
42.                         int i = 0;
    
43.                         for (Character c : target) {
    
44.                                 tmpCs[i++] = c;
    
45.                         }
    
46.                         arrayList.add(new String(tmpCs));
    
47.                         return;
    
48.                 }
    
49.                 for (int i = 0; i < datas.size(); i++) {
    
50.                         List newDatas = new ArrayList(datas);
    
51.                         List newTarget = new ArrayList(target);
    
52.                         newTarget.add(newDatas.remove(i));
    
53.                         sort(newDatas, newTarget, num, arrayList);
    
54.                 }
    
55.         }
    
56. }
    

复制代码