求一個字符串所有的子序列：非遞歸和遞歸算法

比如：字符串abc,子序列：a,b,c,ab,ba,ac,ca,bc,cb,abc,acb,bac,bca,cab,cba

*有重復的，aabbcc，太麻煩，需要一個hashmap對結果進行剔除處理，實際字符數一多，數量是爆發的，假設沒有重復字符

*分兩步：

1：對該字符串的所有字符進行0,1標注，0表示子串不采納該字符，1表示采納
2：對提取字符進行全排列：非遞歸時的考慮：每個字符都有排列序號，假設5個，那么就是00000-44444的5進制逐步+1的過程，實際00000由於各位序號加入hashmap后只有一個成員，沒有意義，只有當加入hashmap后有5個成員的才有意義，比如：12345，12543。遞歸的話：有遞歸初始部分--初始化數據，和遞歸體構成

import java.util.HashMap;
import java.util.ArrayList;

public class Test9 {
    public static void main(String[] args){
        //no_recursive();
        recursive_char_use_entry();
    }
    
    
    static void no_recursive() {
        String original_Str="abcde";
        int[] char_use= new int[100];
        int[] char_order=new int[100];
        String[] single_char = new String[100];
        int single_char_cnt=0;
        int str_len = original_Str.length();
        HashMap<Integer,Integer> used_order=new HashMap<Integer,Integer>();
        
        for(int i=0;i<str_len;i++) char_use[i]=0;
        while(char_use[0]<2) {
            
            for(int i=str_len-1;i>=0;i--){
                if(i==0 || char_use[i]+1<2){
                    char_use[i]++;
                    break;
                }else{
                    char_use[i]=0;
                }
            }
            
            single_char_cnt=0;
            for(int i=0;i<str_len;i++) {
                if(char_use[i] == 1) {
                    single_char[single_char_cnt] = original_Str.substring(i, i+1);
                    single_char_cnt++;
                }
            }

            //
            for(int i=0;i<single_char_cnt;i++) char_order[i]=0;
            while(char_order[0]<single_char_cnt){

                used_order.clear();
                for(int i=0;i<single_char_cnt;i++) used_order.put(char_order[i],i);
                if(used_order.size()== single_char_cnt){
                    for(int i=0;i<single_char_cnt;i++) System.out.print(single_char[used_order.get(i)]);
                    System.out.println("");
                }

                for(int i=single_char_cnt-1;i>=0;i--){
                    if(i==0 || char_order[i]+1<single_char_cnt){
                        char_order[i]++;
                        break;
                    }else{
                        char_order[i]=0;
                    }
                }
                
            }
        }
    }
    
    static void recursive_char_use_entry() {
        String original_Str="abcde";
        int[] char_use= new int[100];
        int str_len = original_Str.length();
        
        recursive_char_use(original_Str,char_use,0,str_len);
    }
    
    static void recursive_char_use(String original_Str,int[] char_use,int char_no,int char_sum) {
        for(int i=0;i<2;i++) {
            char_use[char_no] = i;
            if(char_no == char_sum - 1) {
                recursive_char_order_entry(original_Str,char_use);
            }else {
                recursive_char_use(original_Str,char_use,char_no+1,char_sum);
            }
        }
    }
    
    static void recursive_char_order_entry(String original_Str,int[] char_use) {
        int[] char_order=new int[100];
        String[] single_char = new String[100];
        int single_char_cnt=0;
        HashMap<Integer,Integer> used_order=new HashMap<Integer,Integer>();
        
        for(int i=0;i<original_Str.length();i++) {
            if(char_use[i] == 1) {
                single_char[single_char_cnt] = original_Str.substring(i, i+1);
                single_char_cnt++;
            }
        }
        
        recursive_char_order(single_char,single_char_cnt,used_order);
    }
    static void recursive_char_order(String[] single_char,int single_char_cnt,HashMap<Integer,Integer> used_order) {
        int char_order_cur = used_order.size();
        for(int i=0;i<single_char_cnt;i++) {
            if(used_order.get(i) != null) continue;
            used_order.put(i, char_order_cur);
                if(used_order.size() == single_char_cnt) {
                    for(int r=0;r<single_char_cnt;r++) System.out.print(single_char[used_order.get(r)]);
                    System.out.println("");
                }else {
                    recursive_char_order(single_char,single_char_cnt,used_order);
                }
            used_order.remove(i);
        }
    }
}