La implementación de backtracking del algoritmo de permutación completa se centra en backtracking. Solo si comprendemos completamente el principio de implementación y el proceso de trabajo de backtracking podemos dominar verdaderamente el algoritmo de backtracking.
En el arreglo completo, la matriz de 0 a N se refiere a la cabeza de la matriz a su vez, y luego se organizan completamente los siguientes 1 a N. El punto clave es que al retroceder, los dos elementos que se intercambiaron antes deben ser intercambiado de nuevo para restaurar la matriz, para no afectar el intercambio del siguiente ciclo.
No hay muchas tonterías, solo código.
public class Main {
static int ans=0;//总的排列组合数目
static int[] arr= {1,2,3,4};//要排列的数组
public static void main(String[] args) throws Exception {
perm(arr,0,(arr.length-1));//调用排列函数
System.out.println(ans);//输出总的排列组合数目
}
/**
* 排列函数
* @param arr 要排列的数组
* @param start 要排列的数组的起始位置 即从下标为start开始排列
* @param end 从数组的下标为start到end结束进行排列
*/
public static void perm(int[] arr,int start,int end) {
//排列前先判断，
//如果开始排列的下标和结束的下标一致，说明只排列一个数字，即此次排列完成，需要回溯进行下一次排列
if(start == end) {
print();//打印本次排列的
return;//回溯
}else {
//for循环同理从start开始，到end结束
/**
* 1,2,3,4—>swap(0,0)—>1 [2 3 4] (子递归先不管)—>swap(0,0)—>1,2,3,4
1,2,3,4—>swap(0,1)—>2 [1 3 4] (子递归先不管)—>swap(0,1)—>1,2,3,4
1,2,3,4—>swap(0,2)—>3 [2 1 4] (子递归先不管)—>swap(0,2)—>1,2,3,4
1,2,3,4—>swap(0,3)—>4 [2 3 1] (子递归先不管)—>swap(0,3)—>1,2,3,4
..............
1,2...N—>swap(0,N)—>N [2 3...N-1,1] (子递归先不管)—>swap(0,N)—>1,2,3,4
每次递归完回溯时，要通过再次swap交换，将之前交换的元素还原（以免影响下一次循环），才能进行下一次循环
*/
for (int j = start; j <=end; j++) {
swap(arr, start, j);//将元素提到数组头
perm(arr,start+1,end);//将剩下的数组再进行排列
swap(arr, start, j);//将前面交换的元素换回来，将数组还原，在进行下一次循环排列
}
}
}
//交换函数
public static void swap(int[] arr,int i,int j) {
int temp=arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//打印一次排列结果
private static void print() {
ans++;//解法数+1
for (int i =0 ; i < arr.length -1 ; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
}
}