Leetcode031--集合的所有子集

一、原题

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],
[]
]

一、中文

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

三、举例

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

四、思路

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

五、程序

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

package code;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class LeetCode44{

private static ArrayList<ArrayList<Integer>> result;
private static ArrayList<Integer> l;
private static int[] tmpset;
private static int numer; // 在set中还需要的选择的元素个数

public static void main(String args[]){
int num[] = new int[]{1, 3, 2, 4};

//		ArrayList<ArrayList<Integer>> allSubset = findAllSubset(num);
//		Iterator<ArrayList<Integer>> it1 = allSubset.iterator();

//		while(it1.hasNext()){
//			Iterator<Integer> it2 = it1.next().iterator();
//			while(it2.hasNext()){
//				System.out.print(it2.next()+" ");
//			}
//			System.out.println();
//		}

Set<Set<Integer>> result = getSubSet(num);	//调用方法
//输出结果
for(Set<Integer> subSet: result){
for(Integer i: subSet)
System.out.print(i+" ");

System.out.println("");
}

}

//数组表示的数字进行加一操作，数组的最高位表示的是数字的最低位
public static ArrayList<ArrayList<Integer>> findAllSubset(int set[]) {
result = new ArrayList<ArrayList<Integer>>();

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

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

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

return result;
}

public static Set<Set<Integer>> getSubSet(int[] set){
Set<Set<Integer>> result = new HashSet<Set<Integer>>();	//用来存放子集的集合，如{{},{1},{2},{1,2}}
int length = set.length;
int num = length==0 ? 0 : 1<<(length);	//2的n次方，若集合set为空，num为0；若集合set有4个元素，那么num为16.

//从0到2^n-1（[00...00]到[11...11]）
for(int i = 0; i < num; i++){
Set<Integer> subSet = new HashSet<Integer>();

int index = i;
for(int j = 0; j < length; j++){
if((index & 1) == 1){		//每次判断index最低位是否为1，为1则把集合set的第j个元素放到子集中
subSet.add(set[j]);
}
index >>= 1;		//右移一位
}

result.add(subSet);		//把子集存储起来
}
return result;
}

//通过递归的方式来进行
public static void subset(int start) {

if (numer == 0) {
ArrayList<Integer> tmp = new ArrayList<>();
for (Integer i : l) {
tmp.add(i);
}

result.add(tmp);
return;
}

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

//快速排序
public static void quickSort(int num[], int left, int right){
if(left < right){
int mid = getMid(num, left, right);
quickSort(num, left, mid-1);
quickSort(num, left+1, right);
}
}

//通过交换的方式将两边进行排序，并返回中间的位置
public static int getMid(int num[], int left, int right){
int tmp = num[left];
while(left < right){
while(left < right && num[right] > tmp){
right--;
}
num[left] = num[right];

while(left < right && num[left] < tmp){
left++;
}
num[right] = num[left];
}

num[left] = tmp;

return left;
}

}

------------------------------------------output----------------------------------------

1
2
3
1 2
1 3
4
2 3
1 4
1 2 3
2 4
3 4
1 2 4
1 3 4
2 3 4
1 2 3 4