求一个数组的全部子集（递归解法）

常常会看见一个算法题：求一个数组的子集
例如：
输入：[1,3,5,7]
输出：[1, 3, 5, 7, 1;3, 1;5, 1;7, 3;5, 3;7, 5;7, 1;3;5, 1;3;7, 1;5;7, 3;5;7, 1;3;5;7]
这个解法有很多，这边罗列一份java版本递归解法
基本思路
就是利用递归，压栈出栈
1，3，5，7 为一组
13，15，17 ，35，37，57 为一组
135，137，357 为一组
1357 为一组
也就是说固定前面的数字 依次切换

代码如下：

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.StringJoiner;

/**
 * 求一个数组的全部子集的解法   递归
 *
 * @author xjb
 * @date 2019-03-18 11:26
 **/
public class FindAllSubSetOfSetUtils {

    private static List<Integer> stack = new ArrayList<Integer>();
    private static int[] savenumber = null;
    private static List<String> result = new ArrayList<String>();

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        if (scanner.hasNextInt()) {
            //输入数据
            Integer sum = scanner.nextInt();
            savenumber = new int[sum];
            for (int i = 0; i < sum; i++) {
                savenumber[i] = scanner.nextInt();
            }

            //循环找出 子集长度为 1,2,3...的子集
            for (int i = 1; i <= sum; i++) {
                findAllSubSet(i, 1, 0);
            }
            System.out.println(result.toString());

        }
    }

    /**
     * @param index 子集长度
     * @param stackLength   栈中集合长度
     * @param start 集合开始下标
     * @return
     * @author xjb
     * @date 2019-03-18  14:14:38
     **/
    private static void findAllSubSet(int index, int stackLength, int start) {
        for (int i = start; i < savenumber.length; i++) {
            //放入栈顶
            stack.add(i);
            //栈中数目和此次递归次数相同
            if (stackLength == index) {
                //组装子集
                StringJoiner stringJoiner = new StringJoiner(";");
                for (int j = 0; j < stack.size(); j++) {
                    stringJoiner.add(savenumber[stack.get(j)] + "");
                }
                //放入子集
                result.add(stringJoiner.toString());
            }
            //递归放入数据
            else
                findAllSubSet(index, stackLength + 1, i + 1);
            //取出栈顶元素
            stack.remove(stack.size() - 1);
        }
    }

}