递归递归！！！

字符串的全排列

此处采用的方式将字符串分为两部分

    1. 固定一个字符，将之后的字符串全排列

    2. 将固定字符与之后的字符依次交换

盗图如下，产生的字符串顺序为最后一行从左到右~

代码中有两种包含重复字符的解决方案

    1. 在将重排后的字符串输出时，判断是否重复过，若重复过，则不做处理

    2. 将字符与之后的字符交换时，对于重复的字符仅交换一次，这样避免了重复字符串的出现

首先是递归算法

方案1：

import java.util.*;

public class Solution_permutation {
    public static void main(String[] args) {
        String a = "abb";
        Solution_permutation x = new Solution_permutation();
        System.out.println(x.Permutation(a));
    }
    @SuppressWarnings("null")
    public ArrayList<String> Permutation(String str) {
       ArrayList<String> ans=new ArrayList<String>();//所有排列的可能都在这里
        if(str!=null||str.length()>0){
            help(0,str.toCharArray(),ans);
            Collections.sort(ans);
        }        
        return ans;
    }
    public static void help(int i,char[] cha,ArrayList<String> ans){
        if(i==cha.length-1){
            String val = String.valueOf(cha);
            if(!ans.contains(val)){
                ans.add(val);//避免重复
            }
        }else{
            for(int j=i;j<cha.length;j++){
                swap(i,j,cha);//依次选一个数固定住
                help(i+1,cha,ans);//让后面的进行全排列
                swap(i,j,cha);//恢复原来的模样，回溯关键
            }
        }        
    }
    public static void swap(int i,int j,char[] cha){
        char temp=cha[i];
        cha[i]=cha[j];
        cha[j]=temp;
    }    
}

方案2

import java.util.*;

public class Solution_permutation {
    public static void main(String[] args) {
        String a = "abb";
        Solution_permutation x = new Solution_permutation();
        System.out.println(x.Permutation(a));
    }
    public ArrayList<String> Permutation(String str) {
        ArrayList<String> list=new ArrayList<String>();
        if(str!=null&&str.length()>0){
            PermutationHelper(str.toCharArray(),0,list);
            Collections.sort(list);
        }
        return list;
    }
    private void PermutationHelper(char[] chars,int i,ArrayList<String> list){
        if(i == chars.length-1){
            list.add(String.valueOf(chars));
        }else{
            Set<Character> charSet = new HashSet<Character>();
            for(int j=i;j<chars.length;++j){
                if(j==i||!charSet.contains(chars[j])){//避免重复，即当将字符串进行交换时，若交换的字符之前交换过一次，则该次不再交换。
                    charSet.add(chars[j]);
                    swap(chars,i,j);
                    PermutationHelper(chars,i+1,list);
                    swap(chars,j,i);
                }
            }
        }
    }
    private void swap(char[] cs,int i,int j){
        char temp = cs[i];
        cs[i] = cs[j];
        cs[j] = temp;
    }
}

还是感觉有点混沌。之后需要再看递归递归~~~