【LeetCode-面试算法经典-Java实现】【078-Subsets（子集）】

【078-Subsets（子集）】

---

【LeetCode-面试算法经典-Java实现】【所有题目目录索引】

原题

　　Given a set of distinct integers, nums, return all possible subsets.
　　Note:
　　Elements in a subset must be in non-descending order.
　　The solution set must not contain duplicate subsets.
　　For example,
　　If nums = [1,2,3], a solution is:

[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

题目大意

　　给定一个不同数字的数组，返回它的所有子集。

解题思路

　　先对数组中的元素进行排序，然后再用递归分治法进行求解。

代码实现

算法实现类

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Solution {
    private List> result;
    private List l;
    private int[] set;
    private int num; // 在set中还需要的选择的元素个数

    public List> subsets(int[] S) {
        result = new LinkedList<>();

        if (S != null) {
            l = new ArrayList<>();

            // 对S进行排序处理
            quickSort(S, 0, S.length - 1);

            set = S;
            for (int i = 0; i <= S.length; i++) {
                num = i;
                subset(0);
            }
        }

        // 赋空，加快垃圾回收
        set = null;
        l = null;

        return result;
    }

    /**
     * 求元素个个数是num的子集数
     *
     * @param start 剩余的要挑选的num个元素中，第一个的最小下标
     */
    public void subset(int start) {
        if (num == 0) {
            List tmp = new ArrayList<>();
            for (Integer i : l) {
                tmp.add(i);
            }

            result.add(tmp);
            return;
        }

        int endFirst = set.length - num; // 剩余的要挑选的num个元素中，第一个的最大下标
        for (int i = start; i <= endFirst; i++) {
            l.add(set[i]);
            num--;
            subset(i + 1);
            num++;
            l.remove(new Integer(set[i]));
        }
    }

    private void quickSort(int[] arr, int lo, int hi) {

        if (lo < hi) {

            int mid = getMid(arr, lo, hi);

            quickSort(arr, lo, mid - 1);

            quickSort(arr, mid + 1, hi);
        }

    }

    private int getMid(int[] arr, int lo, int hi) {
        int tmp = arr[lo];
        while (lo < hi) {
            while (lo < hi && arr[hi] > tmp) {
                hi--;
            }
            arr[lo] = arr[hi];

            while (lo < hi && arr[lo] < tmp) {
                lo++;
            }

            arr[hi] = arr[lo];
        }

        arr[lo] = tmp;

        return lo;
    }
}

评测结果

　　点击图片，鼠标不释放，拖动一段位置，释放后在新的窗口中查看完整图片。

特别说明

欢迎转载，转载请注明出处【http://blog.csdn.net/derrantcm/article/details/47248055】