Java蓝桥杯——排列组合

排列组合介绍

排列，就是指从给定n个数的元素中取出指定m个数的元素，进行排序。

组合，则是指从给定n个数的元素中仅仅取出指定m个数的元素，不考虑排序。

全排列（permutation）

以数字为例，全排列就是从“第一个数字”起，“每个数字”分别与它“后面的数字”交换，复杂度为O(n!)

图示：

1. A依次和BC交换
2. 交换一次后不急（如AB交换后，不急着交换AC），target后移，再依次交换
3. 直到target=最后一个数时，停止，输出
4. 返回上一步（很明显，用递归）接着做，此时注意，要把换了的数再还回来

代码：数组实现全排列

package hulaoshi.permutation;
public class Common {
	static void swap(char str[], int a, int b) {
		if (a == b) {
			return;
		}
		char temp = str[a];
		str[a] = str[b];
		str[b] = temp;
	}
	static void printArr(char str[]) {
		for (char c : str) {
			System.out.print(c + " ");
		}
		System.out.println();
	}
}

package hulaoshi.permutation;
public class 全排列 {
	static int count = 0;
	static void permutation(char str[], int t) {
		if (t == str.length - 1) {
			// 3.停止
			System.out.print(++count + ": ");
			Common.printArr(str);
			return;
		}
		for (int i = t; i < str.length; i++) {
			Common.swap(str, t, i);
			// 2.递归
			permutation(str, t + 1);
			// 4.返回上层，换回来
			Common.swap(str, t, i);
		}
	}
	public static void main(String[] args) {
		char str[] = new String("ABC").toCharArray();
		// 1.从0开始
		permutation(str, 0);
	}
}

结果：

1: A B C 
2: A C B 
3: B A C 
4: B C A 
5: C B A 
6: C A B 

组合：数组实现

package hulaoshi.permutation;
public class 组合 {
	static char[] _original = "ABCDE".toCharArray();
	static int N = _original.length;
	static int M = 3;
	static int[] _indexArr = new int[M];
	static void C(int n, int m) {
		// 1.以5取3为例，n=5,m=3,遍历下标【2~4】,取第3个元素【m-1】
		for (int i = m - 1; i <= n - 1; i++) {
			// 2.下标存入
			_indexArr[m - 1] = i;
			if (m == 1) {
				printArr();
				// 4.不要return，循环还要继续
				continue;
			}
			// 3.剩下的递归，剩下i个元素，取m-1个
			C(i, m - 1);
		}
	}
	static void printArr() {
		for (int i : _indexArr) {
			System.out.print(_original[i]);
		}
		System.out.println();
	}
	public static void main(String[] args) {
		C(N, M);
	}
}

结果：

ABC
ABD
ACD
BCD
ABE
ACE
BCE
ADE
BDE
CDE

排列：列表实现

就是一个数字一个数字地扫，为避免递归时，已经确定的数还回（如数组实现全排列时的两个swap，每次递归时创建一个新的ArrayList）

package hulaoshi.permutation;
import java.util.ArrayList;
public class 排列组合2 {
	static char[] _原序列 = "ABC".toCharArray();
	static int total;
	static int n = _原序列.length;
	static int m = 2;
	static void printArray(ArrayList<Integer> lstIdx) {
		for (Integer i : lstIdx) {
			System.out.print(_原序列[i]);
		}
		System.out.println();
	}
	static void A(int m, ArrayList<Integer> lstIdx) {
		if (m == 0) {
			// 递归完毕，打印出来
			printArray(lstIdx);
			total++;
			return;
		}
		for (int i = 0; i < n; i++) {
			// 上一次调用本方法时的ArrayList，不改
			// 创建新的ArrayList，为的是递归完毕时，旧的ArrayList不变
			ArrayList<Integer> lstIdx2 = new ArrayList<Integer>();
			lstIdx2.addAll(lstIdx);
			if (!lstIdx.contains(i)) {
				lstIdx2.add(i);
				// 递归调用，将ArrayList传进去，但函数内会生成新的，把这个完全包含
				A(m - 1, lstIdx2);
			}
		}
	}
	public static void main(String[] args) {
		A(m, new ArrayList<Integer>());
		System.out.println("total : " + total);
	}
}

结果：

AB
AC
BA
BC
CA
CB
total : 6