全排列的递归java
1. 全排列递归算法
希望我的答复可以帮助你加深理解：
第一，perm函数中的条件for(int i=k;i<=m;i++)应更正为 for(int i=k;i<m;i++)
第二，你可以在核心步骤的前后打印有关变量的值，分析查看每一步的具体执行情况，这是编程调试的重要能力，要加强。
第三，以下是我提供的附件程序及运行结果（以1,2,3这个数组的全排列），可辅助分析：
1. 程序源码=================================================
#include <stdio.h>
#include <stdlib.h>
int N,P=0;
void swap(int a[],int i,int j)
{
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
void perm(int a[],int k,int m,int pk,int pm)
{
int i;
/*k为中间变量，m初始化为参与排列元素的起始坐标和终止坐标
pk,pm分别表示参与排列元素的起始坐标和终止坐标，整个递归过程保持不变*/
if(k==m)
{
printf("----->perm %d :\n",P/N+1);/*打印提示*/
for(i=pk;i<pm;i++)
{
printf("%d ",a[i]);
P=P+1;
}
printf("\n\n");
}
else
{
for(i=k;i<m;i++)
{
printf("a %d,%d,%d,%d,%d\n",i,k,a[0],a[1],a[2]);
swap(a,k,i);
printf("b %d,%d,%d,%d,%d\n",i,k,a[0],a[1],a[2]);
perm(a,k+1,m,pk,pm);
printf("c %d,%d,%d,%d,%d\n",i,k,a[0],a[1],a[2]);
swap(a,k,i);
printf("d %d,%d,%d,%d,%d\n",i,k,a[0],a[1],a[2]);
}
}
}
int main()
{
/*调节以下N值及对应数组内容，可打印对应数组对应的全排列*/
N=3;
int t[]={1,2,3};
/*调节以上N值及对应数组内容，可打印对应数组对应的全排列*/
perm(t,0,N,0,N);
printf("----->Over!\n");/*打印提示*/
system("pause");
return 0;
}
2.打印结果 ============================================================
a 0,0,1,2,3
b 0,0,1,2,3
a 1,1,1,2,3
b 1,1,1,2,3
a 2,2,1,2,3
b 2,2,1,2,3
----->perm 1 :
1 2 3
c 2,2,1,2,3
d 2,2,1,2,3
c 1,1,1,2,3
d 1,1,1,2,3
a 2,1,1,2,3
b 2,1,1,3,2
a 2,2,1,3,2
b 2,2,1,3,2
----->perm 2 :
1 3 2
c 2,2,1,3,2
d 2,2,1,3,2
c 2,1,1,3,2
d 2,1,1,2,3
c 0,0,1,2,3
d 0,0,1,2,3
a 1,0,1,2,3
b 1,0,2,1,3
a 1,1,2,1,3
b 1,1,2,1,3
a 2,2,2,1,3
b 2,2,2,1,3
----->perm 3 :
2 1 3
c 2,2,2,1,3
d 2,2,2,1,3
c 1,1,2,1,3
d 1,1,2,1,3
a 2,1,2,1,3
b 2,1,2,3,1
a 2,2,2,3,1
b 2,2,2,3,1
----->perm 4 :
2 3 1
c 2,2,2,3,1
d 2,2,2,3,1
c 2,1,2,3,1
d 2,1,2,1,3
c 1,0,2,1,3
d 1,0,1,2,3
a 2,0,1,2,3
b 2,0,3,2,1
a 1,1,3,2,1
b 1,1,3,2,1
a 2,2,3,2,1
b 2,2,3,2,1
----->perm 5 :
3 2 1
c 2,2,3,2,1
d 2,2,3,2,1
c 1,1,3,2,1
d 1,1,3,2,1
a 2,1,3,2,1
b 2,1,3,1,2
a 2,2,3,1,2
b 2,2,3,1,2
----->perm 6 :
3 1 2
c 2,2,3,1,2
d 2,2,3,1,2
c 2,1,3,1,2
d 2,1,3,2,1
c 2,0,3,2,1
d 2,0,1,2,3
----->Over!
请按任意键继续. . .
2. 全排列的递归
设(ri)perm(X)表示每一个全排列前加上前缀ri得到的排列.当n=1时,perm(R)=(r) 其中r是唯一的元素,这个就是出口条件.
当n>1时,perm(R)由(r1)perm(R1),(r2)perm(R2),...(rn)perm(Rn)构成. voidPerm(list[],intk,intm)//k表示前缀的位置,m是要排列的数目.{if(k==m-1)//前缀是最后一个位置,此时打印排列数.{for(inti=0;i<m;i++){printf(%d,list[i]);}printf(
);}else{for(inti=k;i<m;i++){//交换前缀,使之产生下一个前缀.Swap(list[k],list[i]);Perm(list,k+1,m);//将前缀换回来,继续做上一个的前缀排列.Swap(list[k],list[i]);}}}//此处为引用,交换函数.函数调用多,故定义为内联函数.inlinevoidSwap(int&a,int&b){inttemp=a;a=b;b=temp;}函数Perm(int list[],int k,int m)是求将list的第0~k-1个元素作为前缀、第k~m个元素进行全排列得到的全排列，如果k为0，且m为n，就可以求得一个数组中所有元素的全排列。
其想法是将第k个元素与后面的每个元素进行交换，求出其全排列。这种算法比较节省空间。 n个数的排列可以从1.2....n开始,至n.n-1....2.1结束。
也就是按数值大小递增的顺序找出每一个排列。
以6个数的排列为例，其初始排列为123456,最后一个排列是654321,如果当前排列是124653,找它的下一个排列的方法是，从这个序列中从右至左找第一个左邻小于右邻的数，如果找不到，则所有排列求解完成，如果找得到则说明排列未完成。
本例中将找到46,计4所在的位置为i,找到后不能直接将46位置互换，而又要从右到左到第一个比4大的数，本例找到的数是5，其位置计为j，将i与j所在元素交换125643,然后将i+1至最后一个元素从小到大排序得到125346，这就是124653的下一个排列，如此下去，直至654321为止。算法结束。 intb[N];intis_train(inta[],intn){inti,j,k=1;for(i=1;i<=n;i++){for(j=i+1;j<=n;j++)if(a[j]<a[i])b[k++]=a[j];/*判断是否降序*/if(k>1)is_train(b,k);elsereturn(1);}}voidtrain(inta[],intn){inti,j,t,temp,count=1;t=1;printf(inputthe%3dthway:,count);for(i=1;i<=n;i++)printf(%3d,a[i]);printf(
);while(t){i=n;j=i-1;/*从右往左找,找第一个左邻比右邻小的位置*/while(j&&a[j]>a[i]){j--;i--;}if(j==0)t=0;elset=1;if(t){i=n;/*从右往左找,找第一个比front大的位置*/while(a[j]>a[i])i--;temp=a[j],a[j]=a[i],a[i]=temp;quicksort(a,j+1,N);/*调用快速排序*//*判断是否符合调度要求*/if(is_train(a,N)==1){count++;printf(inputthe%3dthway:,count);for(i=1;i<=n;i++)printf(%3d,a[i]);printf(n);}}}}
3. java全排列 数组
全排列算法很多，这是其中一个，使用递归——
import java.util.ArrayList;
import java.util.List;
public class PermAComb {
static List<int[]> allSorts = new ArrayList<int[]>();
public static void permutation(int[] nums, int start, int end) {
if (start == end) { // 当只要求对数组中一个数字进行全排列时，只要就按该数组输出即可
int[] newNums = new int[nums.length]; // 为新的排列创建一个数组容器
for (int i=0; i<=end; i++) {
newNums[i] = nums[i];
}
allSorts.add(newNums); // 将新的排列组合存放起来
} else {
for (int i=start; i<=end; i++) {
int temp = nums[start]; // 交换数组第一个元素与后续的元素
nums[start] = nums[i];
nums[i] = temp;
permutation(nums, start + 1, end); // 后续元素递归全排列
nums[i] = nums[start]; // 将交换后的数组还原
nums[start] = temp;
}
}
}
public static void main(String[] args) {
int[] numArray = {1, 2, 3, 4, 5, 6};
permutation(numArray, 0, numArray.length - 1);
int[][] a = new int[allSorts.size()][]; // 你要的二维数组a
allSorts.toArray(a);
// 打印验证
for (int i=0; i<a.length; i++) {
int[] nums = a[i];
for (int j=0; j<nums.length; j++) {
System.out.print(nums[j]);
}
System.out.println();
}
System.out.println(a.length);
}
}
4. Java数组的全排列，里面布尔类型的数组vis[ ]，在递归算法里起了什么作用，递归那块理解不了，求详细解答
不要急于看代码，你心理要知道全排列的思路，不注重思路是很多程序员易犯的错误。
全排列算法：
如果我求得固定第一位后的排列，那么全部排列就可以求出，固定第一位有10种可能，可以循环求得。
如果我求得固定第二位后的排列，固定第一位后的排列就可以求出，固定第二位有9种可能，可以循环求得。
。。。
如果我求得固定第10位后的排列，固定第9位后的排列就可以求出，固定第10位有1种可能，可以循环求得。
这很明显是递归的算法。
static void dfs(int start,int end,int num){//为全部排列的集合，start为数字的位置,end为最后一位，num多余的
if(start==end){//当前的数字位置为最后一位时，说明，一个序列已经生成
for(int i=1;i<end;i++)
System.out.print(a[i]+" ");//输出序列
System.out.println();
}
else{//序列没有生成时
for(int i=1;i<end;i++){
if(vis[i])//i是否在前面使用过
continue;//如果是直接跳过
a[start]=i;//确定start位置的数字，当start为1时就是确定第一位，有10种可能
vis[i]=true;//设置i为已使用状态，避免下一位使用i
dfs(start+1,end,num);//求得确定start位后的全部序列
vis[i]=false;//设置i为未使用状态
}
}
5. 关于各种排列组合java算法实现方法
一 利用二进制状态法求排列组合 此种方法比较容易懂 但是运行喊隐颂效率不高 小数据排列组合可以使用
复制代码 代码如下: import java util Arrays;//利用二进制算法进行全排列 //count : //count :
public class test { public static void main(String[] args) { long start=System currentTimeMillis(); count (); long end=System currentTimeMillis(); System out println(end start); } private static void count (){ int[] num=new int []{ }; for(int i= ;i<Math pow( );i++){ String str=Integer toString(i ); int sz=str length(); for(int j= ;j< sz;j++){ str=" "+str; } char[] temp=str toCharArray(); Arrays sort(temp); String gl=new String(temp); if(!gl equals(" ")){ continue; } String result=""; for(int m= ;m<str length();m++){ result+=num[Integer parseInt(str charAt(m)+"")]; } System out println(result); } } public static void count (){ int[] num=new int []{ }; int[] ss=new int []{ }; int[] temp=new int[ ]; while(temp[ ]< ){ temp[temp length ]++; for(int i=temp length ;i> ;i ){ if(temp[i]== ){ temp[i]= ; temp[i ]++; } } int []tt=temp clone(); Arrays sort(tt); if(!Arrays equals(tt ss)){ continue; } String result=""; for(int i= ;i<num length;i++){ result+=num[temp[i]]; } System out println(result); } } }
二 用递归的思想携慧来求排列跟组合 代码量比较大
复制代码 代码如下郑郑: package practice;import java util ArrayList; import java util List;
public class Test {
/** * @param args */ public static void main(String[] args) { // TODO Auto generated method stub Object[] tmp={ }; // ArrayList<Object[]> rs=RandomC(tmp); ArrayList<Object[]> rs=cmn(tmp ); for(int i= ;i<rs size();i++) { // System out print(i+"="); for(int j= ;j<rs get(i) length;j++) { System out print(rs get(i)[j]+" "); } System out println(); } }
// 求一个数组的任意组合 static ArrayList<Object[]> RandomC(Object[] source) { ArrayList<Object[]> result=new ArrayList<Object[]>(); if(source length== ) { result add(source); } else { Object[] psource=new Object[source length ]; for(int i= ;i<psource length;i++) { psource[i]=source[i]; } result=RandomC(psource); int len=result size();//fn组合的长度 result add((new Object[]{source[source length ]})); for(int i= ;i<len;i++) { Object[] tmp=new Object[result get(i) length+ ]; for(int j= ;j<tmp length ;j++) { tmp[j]=result get(i)[j]; } tmp[tmp length ]=source[source length ]; result add(tmp); } } return result; } static ArrayList<Object[]> cmn(Object[] source int n) { ArrayList<Object[]> result=new ArrayList<Object[]>(); if(n== ) { for(int i= ;i<source length;i++) { result add(new Object[]{source[i]}); } } else if(source length==n) { result add(source); } else { Object[] psource=new Object[source length ]; for(int i= ;i<psource length;i++) { psource[i]=source[i]; } result=cmn(psource n); ArrayList<Object[]> tmp=cmn(psource n ); for(int i= ;i<tmp size();i++) { Object[] rs=new Object[n]; for(int j= ;j<n ;j++) { rs[j]=tmp get(i)[j]; } rs[n ]=source[source length ]; result add(rs); } } return result; }
}
三 利用动态规划的思想求排列和组合
复制代码 代码如下: package Acm; //强大的求组合数 public class MainApp { public static void main(String[] args) { int[] num=new int[]{ }; String str=""; //求 个数的组合个数 // count( str num ); // 求 n个数的组合个数 count ( str num); }private static void count (int i String str int[] num) { if(i==num length){ System out println(str); return; } count (i+ str num); count (i+ str+num[i]+" " num); }
private static void count(int i String str int[] num int n) { if(n== ){ System out println(str); return; } if(i==num length){ return; } count(i+ str+num[i]+" " num n ); count(i+ str num n); } }
下面是求排列
复制代码 代码如下: lishixin/Article/program/Java/JSP/201311/20148
6. java中，用递归方法求n个数的无重复全排列，n=3。
程序如下所示，输入格式为：
5
31212
第一行是数字个数，第二行有n个数，表示待排列的数，输入假设待排序的数均为非负数。
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.util.Arrays;
importjava.util.Scanner;
publicclassMain{
staticfinalintmaxn=1000;
intn;//数组元素个数
int[]a;//数组
boolean[]used;//递归过程中用到的辅助变量，used[i]表示第i个元素是否已使用
int[]cur;//保存当前的排列数
//递归打印无重复全排列，当前打印到第idx位
voidprint_comb(intidx){
if(idx==n){//idx==n时，表示可以将cur输出
for(inti=0;i<n;++i){
if(i>0)System.out.print("");
System.out.print(cur[i]);
}
System.out.println();
}
intlast=-1;//因为要求无重复，所以last表示上一次搜索的值
for(inti=0;i<n;++i){
if(used[i])continue;
if(last==-1||a[i]!=last){//不重复且未使用才递归下去
last=a[i];
cur[idx]=a[i];
//回溯法
used[i]=true;
print_comb(idx+1);
used[i]=false;
}
}
}
publicvoidgo()throwsFileNotFoundException
{
Scannerin=newScanner(newFile("data.in"));
//读取数据并排序
n=in.nextInt();
a=newint[n];
for(inti=0;i<n;++i)a[i]=in.nextInt();
Arrays.sort(a);
//初始化辅助变量并开始无重复全排列
cur=newint[n];
used=newboolean[n];
for(inti=0;i<n;++i)used[i]=false;
print_comb(0);
in.close();
}
publicstaticvoidmain(String[]args)throwsFileNotFoundException{
newMain().go();
}
}
客观来说，非递归的无重复全排列比较简单且高效。
7. 在java环境中用递归方法求n个数的无重复全排列，n=3。
给你个思路：
函数内判断
if (元素个数==2){
打印结果：元素1，元素2；
打印结果：元素2，元素1；
} else {
打印结果：元素1，递归本函数(其他元素)；
打印结果：递归本函数(其他元素)，元素1；
}
8. java 输入一个字符串,打印出该字符串中字符的所有排列
实现思路：就是输入字符串后，通过递归的方式，循环每个位置和其他位置的字符。
importjava.util.Scanner;
publicclassDemo001{
public桥茄staticvoidmain(String[]args){
Stringstr="";
Scannerscan=newScanner(System.in);
str=scan.nextLine();
permutation(str.toCharArray(),0);
}
publicstaticvoidpermutation(char[]str,inti){
if(i>=str.length)
敏仿察return;
if(i==str.length-1){
System.out.println(String.valueOf(str));
}else{
for大芹(intj=i;j<str.length;j++){
chartemp=str[j];
str[j]=str[i];
str[i]=temp;
permutation(str,i+1);
temp=str[j];
str[j]=str[i];
str[i]=temp;
}
}
}
}