求一个字符串所有的子序列：非递归和递归算法

比如：字符串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);
        }
    }
}