不懂全排列的看过来！

题目：

假设字符串中的所有字符都不重复，如何输出字符串的所有组合？
例如：abc,

思路：

运用递归的算法，遍历字符串，每个字符串，每个字符只能取或者不取。若取该字符，就把他放到结果字符串中

public class Combine {
    public static void CombineRecursiveImpl(char[] c,int begin,int len,StringBuffer sb){
        if(len == 0){
            System.out.println(sb+" ");
            return;
        }
        if(begin == c.length){
            return;
        }
        sb.append(c[begin]);
        CombineRecursiveImpl(c,begin+1,len-1,sb);
        sb.deleteCharAt(sb.length()-1);
        CombineRecursiveImpl(c,begin+1,len,sb);
    }

    public static void main(String[] args) {
        String s="aab";
        char[] c = s.toCharArray();
        StringBuffer sb = new StringBuffer(" ");
        int len = c.length;
        for(int i=1;i<=len;i++){
            CombineRecursiveImpl(c,0,i,sb);
        }
    }

注明：

采用递归求解，当n的值不是很大的时候，不存在效率低下的问题，但当n比较大的时候，效率会变得很差，因为栈调用次数约为2^n，
为了提高效率，考虑到本题的特性，可以构造一个长度为n的01字符串（或者二进制）表示输出结果中是否包含某个字符，例如“001”表示输出结果中不包含字符ab，只包含c，即结果输出为c。原题就是要求输出“001”到“111”这个（2^n）-1组合的字符串

代码

 public static void Combine(char[] c){
       if(c== null)
           return;
       int len = c.length;
       boolean used[] = new boolean[len];
       char cache[] = new char[len];
       int result = len;
       while (true){
           int index = 0;
           while (used[index]){
               used[index] = false;
               ++result;
               if(++index == len)
                   return;
           }
               used[index] = true;
               cache[--result] = c[index];
               System.out.println(new String(cache).substring(result)+" ");
           }
   }

    public static void main(String[] args) {
        String s="abc";
        char[] c = s.toCharArray();
            Combine(c);
    }