遞歸遞歸！！！

字符串的全排列

此處採用的方式將字符串分爲兩部分

    1. 固定一個字符，將以後的字符串全排列

    2. 將固定字符與以後的字符依次交換

盜圖以下，產生的字符串順序爲最後一行從左到右~

 

代碼中有兩種包含重複字符的解決方案

    1. 在將重排後的字符串輸出時，判斷是否重複過，若重複過，則不作處理

    2. 將字符與以後的字符交換時，對於重複的字符僅交換一次，這樣避免了重複字符串的出現

首先是遞歸算法

方案1：

 1 import java.util.*;
 2 
 3 public class Solution_permutation {
 4     public static void main(String[] args) {
 5         String a = "abb";
 6         Solution_permutation x = new Solution_permutation();
 7         System.out.println(x.Permutation(a));
 8     }
 9     @SuppressWarnings("null")
10     public ArrayList<String> Permutation(String str) {
11        ArrayList<String> ans=new ArrayList<String>();//全部排列的可能都在這裏
12         if(str!=null||str.length()>0){
13             help(0,str.toCharArray(),ans);
14             Collections.sort(ans);
15         }        
16         return ans;
17     }
18     public static void help(int i,char[] cha,ArrayList<String> ans){
19         if(i==cha.length-1){
20             String val = String.valueOf(cha);
21             if(!ans.contains(val)){
22                 ans.add(val);//避免重複 23             }
24         }else{
25             for(int j=i;j<cha.length;j++){
26                 swap(i,j,cha);//依次選一個數固定住
27                 help(i+1,cha,ans);//讓後面的進行全排列
28                 swap(i,j,cha);//恢復原來的模樣，回溯關鍵
29             }
30         }        
31     }
32     public static void swap(int i,int j,char[] cha){
33         char temp=cha[i];
34         cha[i]=cha[j];
35         cha[j]=temp;
36     }    
37 }

方案2

 1 import java.util.*;
 2 
 3 public class Solution_permutation {
 4     public static void main(String[] args) {
 5         String a = "abb";
 6         Solution_permutation x = new Solution_permutation();
 7         System.out.println(x.Permutation(a));
 8     }
 9     public ArrayList<String> Permutation(String str) {
10         ArrayList<String> list=new ArrayList<String>();
11         if(str!=null&&str.length()>0){
12             PermutationHelper(str.toCharArray(),0,list);
13             Collections.sort(list);
14         }
15         return list;
16     }
17     private void PermutationHelper(char[] chars,int i,ArrayList<String> list){
18         if(i == chars.length-1){
19             list.add(String.valueOf(chars));
20         }else{
21             Set<Character> charSet = new HashSet<Character>();
22             for(int j=i;j<chars.length;++j){
23                 if(j==i||!charSet.contains(chars[j])){//避免重複，即當將字符串進行交換時，若交換的字符以前交換過一次，則該次再也不交換。 24                     charSet.add(chars[j]);
25                     swap(chars,i,j);
26                     PermutationHelper(chars,i+1,list);
27                     swap(chars,j,i);
28                 }
29             }
30         }
31     }
32     private void swap(char[] cs,int i,int j){
33         char temp = cs[i];
34         cs[i] = cs[j];
35         cs[j] = temp;
36     }
37 }

仍是感受有點混沌。以後須要再看遞歸遞歸~~~