字符排序 蓝桥杯真题

算法是这样的，如果给定N个不同字符，将这N个字符全排列，最终的结果将会是N!种。如：给定 A、B、C三个不同的字符，则结果为：ABC、ACB、BAC、BCA、CAB、CBA一共3!=3*2=6种情况。

packageQuestion1_9;
importjava.util.Scanner;
importjava.util.Vector;

publicclass Question1 {
         public static long count=0;
         private void fullPermutation(Vector<Character>sourse,Vector<Character> result) {
                   if(sourse.size()==0){
                            for (int i = 0; i< result.size(); i++) {
                                     System.out.print(result.elementAt(i));
                            }
                            System.out.print("\n");
                            count++;
                            return;
                   }
                                     for (int i= 0; i < sourse.size(); i++) {
                            Vector<Character>tsourse=newVector<Character>(sourse);
                            Vector<Character>tresult=newVector<Character>(result);
                            tresult.add(sourse.elementAt(i));
                            tsourse.remove(i);
                            newQuestion1().fullPermutation(tsourse, tresult);
                   }
         }

         public static void main(String[] args){
                   Scanner scanner=newScanner(System.in);
                   int n=scanner.nextInt();
                   Vector<Character>sourse=new Vector<Character>();
                   Vector<Character>result=new Vector<Character>();
                   for (int i = 0; i < n;i++) {
                            sourse.add((char)('A'+i));
                   }

                   newQuestion1().fullPermutation(sourse, result);
                   System.out.println(Question1.count);
         }
}

方法二：

importjava.util.ArrayList; 
importjava.util.Iterator; 
importjava.util.LinkedHashSet; 
importjava.util.List; 
importjava.util.Scanner; 
importjava.util.Set; 

publicclass Demo03 { 
    // 去掉重复元素,放入lis  
    public static void removeDuplicate(Strings,Set<Character> lis){ 
        for(char x:s.toCharArray()){ 
            lis.add(x); 
        } 
    } 
    // 为方便操作 将 sets 转 lis   
    public static voidconvert(List<Character> lis,Set<Character> sets){ 
        Iterator<Character> iter =sets.iterator(); 
        while(iter.hasNext()){ 
            lis.add(iter.next()); 
        } 
    } 
    // 检测符合条件的元素组合  
    public static voidcheck(Set<Character> sets){ 
        List<Character> lis = newArrayList<Character>(); 
        convert(lis,sets);  // 为方便操作 将 sets 转 lis   
        StringBuffer sb = newStringBuffer(); 
        for(inti=0;i<lis.size()-2;i++){ 
            for(intj=i+1;j+1<lis.size();j++){   // 向后添加两位,所以 j+1<lis.size()  
                for(int k=j+1;k<lis.size();k++){ 
                    sb.append(lis.get(i)); 
                    sb.append(lis.get(j)); 
                    sb.append(lis.get(k)); 
                    System.out.println(sb); // 输出组合  
                    sb.setLength(0);    // 清空  
               } 
            } 
        } 

    } 
    public static void main(String[]args){ 
        Scanner scan = newScanner(System.in); 
        System.out.println("输入串（不大于30个字符）。"); 
        String s = scan.nextLine(); 
        Set<Character> sets = newLinkedHashSet<Character>(); 
        removeDuplicate(s,sets);    // 去掉重复元素,放入lis  
        check(sets);    // 检测符合条件的元素组合  
    } 
} 

运行结果:
输入串（不大于30个字符）。
abcd
abc
abd
acd
bcd