Ⅰ 如何生成一串数字的全排列 算法
个人一点见解，希望对你有所帮助。
依我之见，你的对换部分出了一点点问题。只要作如下修改即可：
1、exchange 改为：
procere exchange(l,r:integer);
var
t,len:integer;
begin
if l=r then exit;
len:=r-l+1;
len:=len div 2;
for i:=1 to len do
begin
t:=a[l+i-1];
a[l+i-1]:=a[r-i+1];
a[r-i+1]:=t;
end;
end;
2、主过程中exchange(p,n)改为exchange(i+1,n)。
Ⅱ 关于全排列递归算法
这个算法，是把每一个数与末尾的数逐一交换，
k>m 说明已交换完毕，就输出了，这是递归的结束条件。
要学到一定的基本功才能明白。
---------------------------------------------------------------------------
我这个程序，我也编过，放在西祠C++BUILDER论坛里。
你先要掌握，排列的方法才能看懂这个程序。
在这知道里，也答过两次。
为了增加可理解性，我略改了一下方法，我的方法
与你的方法递归方向不同。
http://www.xici.net/d190786398.htm
此算法为递归法显示排列数，没发现比这更简单、明了的递
归算法。此算法只要练智商的作用，没有其它实用价值，阶
乘级的占用时间、空间，数一大，堆栈很快暴了。
算法的要点：
1.列N个数的排列，可化为N个的N-1阶排列：
最末一个数是 D[n-1]，把这个位置的N个数的可能性列出，
就是每一个数 与末尾逐一交换位置，就是N种情况，每一种
情况再求N-1的全排列，就是递归调用了；
交换位置后，就调用自已，但必须恢复刚才的交换，以便下一次
交换；
2.当阶数递归到1时，就直接输出这N个数；
Ⅲ 关于全排列算法实现（请帮忙注释这些代码）
全排列用的是
置换算法，
算法这东西重在理解。具体代码并不那么重要。
全排列是将一组数按一定顺序进行排列，如果这组数有n个，那么全排列数为n!个。现以{1,
2,
3,
4,
5}为
例说明如何编写全排列的递归算法。
1、首先看最后两个数4,
5。
它们的全排列为4
5和5
4,
即以4开头的5的全排列和以5开头的4的全排列。
由于一个数的全排列就是其本身，从而得到以上结果。
2、再看后三个数3,
4,
5。它们的全排列为3
4
5、3
5
4、
4
3
5、
4
5
3、
5
3
4、
5
4
3
六组数。
即以3开头的和4,5的全排列的组合、以4开头的和3,5的全排列的组合和以5开头的和3,4的全排列的组合.
从而可以推断，设一组数p
=
{r1,
r2,
r3,
...
,rn},
全排列为perm(p)，pn
=
p
-
{rn}。
因此perm(p)
=
r1perm(p1),
r2perm(p2),
r3perm(p3),
...
,
rnperm(pn)。当n
=
1时perm(p}
=
r1。
为了更容易理解，将整组数中的所有的数分别与第一个数交换，这样就总是在处理后n-1个数的全排列。
算法如下：
#include
<stdio.h>
int
n
=
0;
void
swap(int
*a,
int
*b)
{
int
m;
m
=
*a;
*a
=
*b;
*b
=
m;
}
void
perm(int
list[],
int
k,
int
m)
{
int
i;
if(k
>
m)
{
for(i
=
0;
i
<=
m;
i++)
printf("%d
",
list[i]);
printf("\n");
n++;
}
else
{
for(i
=
k;
i
<=
m;
i++)
{
swap(&list[k],
&list[i]);
perm(list,
k
+
1,
m);
swap(&list[k],
&list[i]);
}
}
}
int
main()
{
int
list[]
=
{1,
2,
3,
4,
5};
perm(list,
0,
4);
printf("total:%d\n",
n);
return
0;
}
Ⅳ 递归的全排列产生算法
我说说我对这段程序的大致理解过程。水平有限，难免纰漏。
咋一看我也理解不了，只是知道了函数第二个参数i表示首元素，第三个参数n表示尾元素。于是我开始按照数学归纳法的方式来理解（我一直觉得递归算法要按照数学归纳法的方式才好理解）。
我印象中数学归纳法的要点好像是包括如下2点：
1.初始的几种情况，即n=0，n=1的情况；
2.第k次与第k-1次间的关系，即已知第k-1次的结果，如何求出第k次的结果。
放到这个问题中：
1.通过考虑n=0，n=1等的几种情况，我大概知道了这个函数的最终结果是打印出一组全排列。不过有些实现细节还没完全明白。
2.已知k-1个元素的全排列，如何求出k个元素的全排列？结合perm函数中的递归调用是把第二个参数加1，我就想出这个问题的答案了：首先确定首元素的值，这样，需要全排列的元素就少了1个，递归也就成立了。
想到这里应该就差不多了，整个算法的思路是：
从元素0开始依次确定各个元素的值，当确定了最后一个元素的值时，就打印整个数组。
最后回答下你的问题：
1.if语句就是当确定了最后一个元素的值后的处理；
2.两个swap实现的就是确定首元素的算法。
另外这里要用两个swap是为了保证全排列后各元素顺序不会乱，否则会出现将相同的元素swap到首位置的情况。这个结论是我又用了一次数学归纳法的思考方式才得出的。
Ⅳ 求遍历全排列的算法
全排列的生成算法就是对于给定的字符集，用有效的方法将所有可能的全排列无重复无遗漏地枚举出来。
常见的有四种全排列算法：
(A)字典序法
(B)递增进位制数法
(C)递减进位制数法
(D)邻位对换法
这里着重介绍字典序法
对给定的字符集中的字符规定了一个先后关系，在此基础上规定两个全排列的先后是从左到右逐个比较对应的字符的先后。
[例]字符集{1,2,3},较小的数字较先,这样按字典序生成的全排列是:123,132,213,231,312,321。
[注意] 一个全排列可看做一个字符串，字符串可有前缀、后缀。
1）生成给定全排列的下一个排列 所谓一个的下一个就是这一个与下一个之间没有其他的。这就要求这一个与下一个有尽可能长的共同前缀，也即变化限制在尽可能短的后缀上。
[例]839647521是1--9的排列。1—9的排列最前面的是123456789，最后面的是987654321，从右向左扫描若都是增的，就到了987654321，也就没有下一个了。否则找出第一次出现下降的位置。
Ⅵ 求全排列的算法
组合数学书里面有。
Ⅶ 关于全排列的算法问题
最低0.27元/天开通网络文库会员，可在文库查看完整内容>
原发布者:ON9V4Xr2gU9J7
全排列以及相关算法在程序设计过程中，我们往往要对一个序列进行全排列或者对每一个排列进行分析。全排列算法便是用于产生全排列或者逐个构造全排列的方法。当然，全排列算法不仅仅止于全排列，对于普通的排列，或者组合的问题，也可以解决。本文主要通过对全排列以及相关算法的介绍和讲解、分析，让读者更好地了解这一方面的知识，主要涉及到的语言是C和C++。本文的节数：1.全排列的定义和公式：2.时间复杂度：3.列出全排列的初始思想：4.从第m个元素到第n个元素的全排列的算法：5.全排列算法：6.全排列的字典序：7.求下一个字典序排列算法：8.C++STL库中的next_permutation()函数：（#include）9.字典序的中介数，由中介数求序号：10.由中介数求排列：11.递增进位制数法：12.递减进位制数法：13.邻位对换法：14.邻位对换法全排列：15.邻位对换法的下一个排列：16.邻位对换法的中介数：17.组合数的字典序与生成：由于本文的，内容比较多，所以希望读者根据自己的要求阅读，不要一次性读完，有些章节可以分开读。第1节到第5节提供了全排列的概念和一个初始的算法。第6节到第8节主要讲述了字典序的全排列算法。第9到第10节讲了有关字典序中中介数的概念。第11到第12节主要介绍了不同的中介数方法，仅供扩展用。第13节到15节介绍了邻位对换法的全排的有关知识。16节讲了有关邻位对换法的中介数，仅供参考。第17节讲了
Ⅷ java 全排列算法
递归实现，取数字（字符串）中第i个位置的字符，然后将他和剩余的字符拼接，剩余的字符串当成有一个全排列的输入，这样递归下去，只剩一个字符时全排列就是本身。程序中使用set去除了重复的数据，如果需要保留，将set换为list接口即可。
package mytest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
/*
* @date:2012-2-8
* @author:
*
* 输入一个数字，讲输出 1到这个数字的全排列
*/
public class MyDemo2 {
private static Set<String> SET_STRING = new HashSet<String>();
private static Set<Long> SET_NUM = new HashSet<Long>();
public static void main(String[] args) {
System.out.println("begin ...... ");
testLong(234);
testString("a23");
print(SET_NUM);
print(SET_STRING);
System.out.println("end ...... ");
}
/**
* 测试数字
* @param num
*/
private static void testLong(long num){
long testNum = num;
String[] permutation;
for(long l=0; l<=testNum; l++){
permutation = getAllOrder(String.valueOf(l));
for (int i = 0; i < permutation.length; i++) {
SET_NUM.add(Long.valueOf(permutation[i]));
}
}
}
/**
* 测试字符串
* @param str
*/
private static void testString(String str){
String[] permutation = getAllOrder(str);
for (int i = 0; i < permutation.length; i++) {
SET_STRING.add(permutation[i]);
}
}
private static void print(Set set){
System.out.println("/*****************************************************/");
int i=0;
for(Iterator it = set.iterator(); it.hasNext();){
i++;
if(i%10 == 0){
System.out.println();
}
System.out.print(it.next() + " ");
}
System.out.println();
System.out.println("/*****************************************************/");
}
/**
* 递归算法 全排列 去除重复
* @param str
* @return
*/
private static String[] getAllOrder(String str) {
String [] arrResult = null;
Set<String> set = new HashSet<String>();
if(str.length()>1){
String result = "";
String charXInString;
String remainString;
for (int i = 0; i < str.length(); i++) {
charXInString = str.charAt(i) + "";
remainString = str.substring(0, i)+ str.substring(i + 1, str.length());
for (String element : getAllOrder(remainString)) {
result = charXInString + element;
set.add(result);
}
}
arrResult = set.toArray(new String[set.size()]);
}else{
arrResult = new String[]{str};
}
return arrResult;
}
}
Ⅸ 全排列递归算法
希望我的答复可以帮助你加深理解：
第一，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!
请按任意键继续. . .