数字排列组合

思路参考上一遍博客：https://blog.csdn.net/qq_32679835/article/details/90041784

一、数字排列

1、数字排列每一次不能将传入的数组直接传入添加到Arraylist中，如果直接添加，在每一次递归添加之后只是通过浅拷贝传入到ArrayList中，就会导致ArrayList中的元素都相同，需要原数组拷贝后传入

2、去重手段不能选择HashSet去重，而是需要在递归过程中判断，判断当前位置的元素在之前元素中已经出现则不能置换

/**
	 * 
	 * bench位置与pionter-----bench-1位置是否交换
	 * 
	 * @param str
	 * @param pointer
	 * @param j
	 * @return
	 */
	public boolean isSwap(int[] str, int pointer, int bench) {
		boolean flag = true;
		for (int i = pointer; i < bench; i++) {
			if (str[bench] == str[i]) {
				flag = false;
			}
		}
		return flag;
	}

3、代码

ArrayList<int[]> list = new ArrayList<>();

    //主函数
	public ArrayList<int[]> Per(int[] arr) {
		if (arr == null || arr.length == 0) {
			return null;
		}
		int pointer = 0;
		oper(arr, pointer,arr.length);
		return list;
	}
	/**
	 * 数字全排列问题
	 * @param arr
	 * @param pointer
	 * @param end
	 */
	private void oper(int[] arr, int pointer,int end) {
		int[] temp = new int[arr.length];
		if (pointer == arr.length) {
			for (int i = 0; i < arr.length; i++) {
				temp[i] = arr[i];
			}
			list.add(temp);
			return;
		} else {
			for (int i = pointer; i < end; i++) {
				if(isSwap(arr, pointer, i)) {
					swap(arr, i, pointer);
					oper(arr, pointer + 1,end);
					swap(arr, pointer, i);
				}
				
			}
		}
	}

二、数字组合

1、最终存储结构ArrayList<ArrayList<Integer>> res = new ArrayList<>();

2、去重方式采取HashSet去重

3、同样由于ArrayList与String的差别，ArrayList中存储一种结果，不能直接添加到res结构中，需要通过临时变量来赋值，保证了结果不会堆积在一起

4、代码

/**
	 * 数字组合问题
	 * @param arr
	 * @return
	 */
	ArrayList<ArrayList<Integer>> res = new ArrayList<>();
	HashSet<ArrayList<Integer>> setcom = new HashSet<>();
	public ArrayList<ArrayList<Integer>> combination(int[] arr) {
		if(arr==null || arr.length== 0) {
			return null;
		} 
		com(arr,0,new ArrayList<Integer>());
		return res;
	}
	private void com(int[] arr, int pointer, ArrayList<Integer> step) {
		ArrayList<Integer> temp = new ArrayList<>();
		for (int i = 0; i < step.size(); i++) {
			temp.add(step.get(i));
		}
		if(pointer == arr.length) {
			if(!setcom.contains(temp)) {
				res.add(temp);
				setcom.add(temp);
				return ;
			}
			
		}else {
			com(arr, pointer+1, temp);
			temp.add(arr[pointer]);
			com(arr, pointer+1, temp);
		}
	}

三、测试

public static void main(String[] args) {
		int[] str = { 1, 1, 3 };
		PermutationData data = new PermutationData();
		System.out.println("===========排列=============");
		ArrayList<int[]> res = data.Per(str);
		for (int j = 0; j < res.size(); j++) {
			System.out.println();
			for (int i = 0; i < res.get(j).length; i++) {
				System.out.print(res.get(j)[i] + " ");
			}
		}
		System.out.println("\n===========组合===============");
		ArrayList<ArrayList<Integer> > rescom = data.combination(str);
		for(int i=0; i<rescom.size();i++) {
			System.out.println();
			for (int j = 0; j < rescom.get(i).size(); j++) {
				System.out.print( rescom.get(i).get(j)+" ");
			}
		}
		
		
	}

四、结果

===========排列=============

1 1 3 
1 3 1 
3 1 1 
===========组合===============


3 
1 
1 3 
1 1 
1 1 3