全排列生成算法
全排列的几种算法
全排列的⼏种算法全排列，我们⾼中时就学过，数学上很简单，可是⽤计算机的算法实现还是有点味道的，今天我将我碰到的⼏种算法如数奉上，欢迎交流！第⼀种：递归最常见的也是最好理解的⽅法：简单点：⽐如"a" ,"b","c"全排列，可以看做事"a" +"b","c"的全排列及"b"+ "a","c"的全排列及"c" + "a","b"的全排列也就是说，遍历原数组中的每个元素，让剩余的元素全排列，这样就找到规律了。
代码如下：public static void main(String[] args) {char buf[]={'a','b','c','d'};perm(buf,0,buf.length-1);}public static void perm(char[] buf,int start,int end){if(start==end){//当只要求对数组中⼀个字母进⾏全排列时，只要就按该数组输出即可（特殊情况）for(int i=0;i<=end;i++){System.out.print(buf[i]);}System.out.println();}else{//多个字母全排列（普遍情况）for(int i=start;i<=end;i++){//（让指针start分别指向每⼀个数）char temp=buf[start];//交换数组第⼀个元素与后续的元素buf[start]=buf[i];buf[i]=temp;perm(buf,start+1,end);//后续元素递归全排列temp=buf[start];//将交换后的数组还原buf[start]=buf[i];buf[i]=temp;}}}第⼆中⽅法：也是递归，但是和第⼀种有所区别，算法：将数据分为两部分，递归将数据从左侧移右侧实现全排列⽐较抽象，如list abcd，遍历每⼀个数，将每个数放到⼀个新的list中,并将该元素从原list删除，然后将剩下的元素继续遍历每个元素继续放到新的list ⾥，这样，当list的长度为原list长度，或者原list长度为0时打印结果！下⾯是简单的⽰意图：// abcd//bcd a//cd ab//d abc//abcd//c abd//abdc//bd ac//d acb//acbd//b acd//acdb//bc ad ...//acd b ...//abd c ...//abc d ...源代码如下：private static void sort(List datas, List target) {//System.out.println("size="+datas.size());if (datas.size()==0) {for (Object obj : target)System.out.print(obj+" ");System.out.print(" ");return;}for (int i = 0; i < datas.size(); i++) {List newDatas = new ArrayList(datas);List newTarget = new ArrayList(target);newTarget.add(newDatas.get(i));newDatas.remove(i);sort(newDatas, newTarget);}}public static void main(String[] args) {List list = new ArrayList();for(int i=0;i<5;i++){list.add(i+1);}sort(list, new ArrayList());}第三种⽅法：⾮递归直接上代码：public static void main(String[] args) {int[] arr = new int[]{1,2,3,4,5,6};for(int i :arr){System.out.print(i + " ");}System.out.println();int totalnum = 1;while(NextNumber(arr,arr.length)){for(int i :arr){System.out.print(i + " ");}System.out.println();totalnum ++;}System.out.println("Total Num: " + totalnum);}private static Boolean NextNumber(int[] arr, int n){//数组最后⼀个元素位置int lastIndex = n-1;//从右向左确定第⼀个数字（前⾯的数字⽐它⼩）int firstIndex = lastIndex;for(;arr[firstIndex-1]>arr[firstIndex];firstIndex--){if(firstIndex == 1){//已经轮询完毕,此数已经是最⼤的那个数return false;}}//从右向左确定⼀个交换数（此数⽐arr[firstIndex]⼩且⽐arr[firstIndex-1]⼤）int swapIndex = lastIndex;for(;swapIndex > firstIndex;swapIndex--){if(arr[swapIndex] < arr[firstIndex] && arr[swapIndex] > arr[firstIndex-1]){break;}}//交换数字swap(arr,firstIndex-1,swapIndex);//将firstIndex右边的数字排序for(;firstIndex < lastIndex;firstIndex++,lastIndex--){if(arr[firstIndex] > arr[lastIndex]){swap(arr,firstIndex,lastIndex);}}return true;}private static void swap(int[] arr,int i, int j){int tmp = arr[i];arr[i] = arr[j];arr[j] = tmp;}如果此⽂对你有帮助，请留个⾔，新⼈需要打架的⽀持和⿎励！。
全排列生成算法
全排列的生成算法对于给左的字符集，用有效的方法将所有可能的全排列无重复无遗漏地枚举出来。
字典序法按照字典序求下一个排列的算法广例字符集{1,2,3},较小的数字较先,这样按字典序生成的全排列是：123,132,213,231,312,321o注意一个全排列可看做一个字符串，字符串可有前缀、后缀/生成给泄全排列的下一个排列所谓一个全排列的下一个排列就是这一个排列与下一个排列之间没有其他的排列。
这就要求这一个排列与下一个排列有尽可能长的共同前缀，也即变化限制在尽可能短的后缀上。
广例839647521是1—9的排列。
1—9的排列最前而的是123456789,最后而的是987654321,从右向左扫描若都是增的，就到了987654321,也就没有下一个了。
否则找出第一次出现下降的位置。
算法：由P1P2...Pn生成的下一个排列的算法如下：1求j=max{j| Pj-I<pj}2.求|=max{k| Pi-1<Pk }3.交换Pi-1与PI得到P1P2...PI-1 （P i....Pn ）,将红色部分顺序逆转，得到结果.例求839647521的下一个排列1.确定i,从左到右两两比较找出后一个数比前一个大的组合，在这里有39 47,然后i 取这些组中最到的位宜号（不是最大的数）在这两组数中7的位置号最大为6,所以i=62.确立I.找岀在i （包括i）后面的所有比i前面那一位大的数的最大的位置号，在此例中7, 5都满足要求，则选5, 5的位置号为7,所以1=73.先将4和5交换，然后将5后的四位数倒转得到结果8396574213 839651247以上算法是在数论课上老师给岀的关于字典序全排列的生成算法，以前也经常要用到全排列生成算法来生成一个全排列对所有的情况进行测试，每次都是现到网上找一个算法，然后直接copy代码，修改一下和自己的程序兼容就行了，也不看是怎么来的，不是我不想看，实在是说的很抽象，那一大堆公式来吓人，一个实例都不给，更有甚者连算法都没有，只是在那里说，想看都看不懂，也没那个耐心取理解那些人写出来的那种让人无法忍受的解释。
全排列问题的解析
1.5全排列的生成算法全排列的生成算法就是对于给定的字符集，用有效的方法将所有可能的全排列无重复无遗漏地枚举出来。
这里介绍全排列算法四种：(A)字典序法(B)递增进位制数法(C)递减进位制数法(D)邻位对换法1.5.1字典序法对给定的字符集中的字符规定了一个先后关系，在此基础上规定两个全排列的先后是从左到右逐个比较对应的字符的先后。
[例]字符集{1,2,3},较小的数字较先,这样按字典序生成的全排列是:123,132,213,231,312,321。
[注意] 一个全排列可看做一个字符串，字符串可有前缀、后缀。
1）生成给定全排列的下一个排列所谓一个的下一个就是这一个与下一个之间没有其他的。
这就要求这一个与下一个有尽可能长的共同前缀，也即变化限制在尽可能短的后缀上。
[例]839647521是1--9的排列。
1—9的排列最前面的是123456789，最后面的是987654321，从右向左扫描若都是增的，就到了987654321，也就没有下一个了。
否则找出第一次出现下降的位置。
/1.5.2递增进位制数法1)由排列求中介数在字典序法中，中介数的各位是由排列数的位决定的.中介数位的下标与排列的位的下标一致。
在递增进位制数法中，中介数的各位是由排列中的数字决定的。
即中介数中各位的下标与排列中的数字(2—n)一致。
可看出n-1位的进位链。
右端位逢2进1，右起第2位逢3进1，…，右起第i位逢i+1进1，i=1,2,…,n-1. 这样的中介数我们称为递增进位制数。
上面是由中介数求排列。
由序号（十进制数）求中介数（递增进位制数）如下：m=m1,0≤m≤n!-1m1=2m2+kn-1,0≤kn-1≤1m2=3m3+kn-2,0≤kn-2≤2……………mn-2=(n-1)mn-1+k2,0≤k2≤n-2mn-1=k1,0≤k1≤n-1p1p2…pn←→(k1k2…kn-1)↑←→m在字典序法中由中介数求排列比较麻烦，我们可以通过另外定义递增进位制数加以改进。
全排列的生成算法
全排列的生成算法全排列的生成算法就是对于给定的字符集，用有效的方法将所有可能的全排列无重复无遗漏地枚举出来。
任何n 个字符集的排列都可以与1～n的n个数字的排列一一对应，因此在此就以n个数字的排列为例说明排列的生成法。
n个字符的全体排列之间存在一个确定的线性顺序关系。
所有的排列中除最后一个排列外，都有一个后继；除第一个排列外，都有一个前驱。
每个排列的后继都可以从它的前驱经过最少的变化而得到，全排列的生成算法就是从第一个排列开始逐个生成所有的排列的方法。
全排列的生成法通常有以下几种：字典序法递增进位数制法递减进位数制法邻位交换法递归类算法1.字典序法字典序法中，对于数字1、2、3......n的排列，不同排列的先后关系是从左到右逐个比较对应的数字的先后来决定的。
例如对于5个数字的排列12354和12345，排列12345在前，排列12354在后。
按照这样的规定，5个数字的所有的排列中最前面的是12345，最后面的是54321。
字典序算法如下：设P是1～n的一个全排列:p=p1p2......pn=p1p2......pj-1pjpj+1......pk-1pkpk+1......pn1）从排列的右端开始，找出第一个比右边数字小的数字的序号j（j从左端开始计算），即j=max{i|pi<pi+1}2）在pj的右边的数字中，找出所有比pj大的数中最小的数字pk，即 k=max{i|pi>pj}（右边的数从右至左是递增的，因此k是所有大于pj的数字中序号最大者）3）对换pi，pk4）再将pj+1......pk-1pkpk+1pn倒转得到排列p’’=p1p2.....pj-1pjpn.....pk+1pkpk-1.....pj+1，这就是排列p的下一个下一个排列。
例如839647521是数字1～9的一个排列。
从它生成下一个排列的步骤如下：自右至左找出排列中第一个比右边数字小的数字4 839647521在该数字后的数字中找出比4大的数中最小的一个5 839647521将5与4交换 839657421将7421倒转 839651247所以839647521的下一个排列是839651247。
组合数学 第一章 排列组合5全排列的生成算法合
1.5.2字典序法
[例] 求839647521的下一个排列
找出比右边数字小的标号最大的数4
8397655 72124124517
44><＜2157
大小为于于后44的的缀用用橙绿色 色表 表示 示
在 找接后出上即缀其前87中后3缀59比2将861缀4344中此97大、变65找后52的1得5出为缀的标到比对翻7下号84换转一3大2最916个的大5。1数的24数77 5
1.5.2字典序法
对给定的字符集中的字符 规定了一个先后关系，在此基 础上规定两个全排列的先后是 从左到右逐个比较对应的字符 的先后。
1.5.2字典序法
[例]字符集{1,2,3},较小的数字较 先,这样按字典序生成的全排列是: 123,132,213,231,312,321。
※※ 一个全排列可看做一个字符串，字
规则：令n个元素为1，2,…,n. p p1 p2 pn 是 这n个数的任意一个排列，我们可以找到一 个序列和它对应，其中ai 可以看作是排列P中 数i+1所在位置右边比i+1小的数的个数。
例 排列3214，它是元素1，2，3，4的一个 排列, 它对应的序列是什么？
例 序列311对应的排列是什么？
练习
求839763ห้องสมุดไป่ตู้421的下一个排列
1.5.3邻位对换法
序数法和字典排序法，求下一个排列在 不进位的情况下很容易。这就启发我们， 能不能设计一种算法，下一个排列总是 上一个排列某相邻两位对换得到的。
活动状态
以1←2←3←4←为初始排列，箭头所指一侧，相邻 的数比它小时，则称该数组处在活动状态， 1 2 3←4←的←2←，3，4都处于的活动状态。
符串可有前缀、后缀。
排列组合的计算公式和算法
排列组合的计算公式和算法
排列组合的计算公式是：
全排列：A(n,n)=n!
组合：C(n,m)=A(n,m)/A(m,m)=n!/(m!*(n-m)!)
这个计算公式是通过对排列组合的一些基本概念的分析所得，所以其算法就是将排列组合的基本概念结合起来，从而得出最终计算结果。
具体的步骤如下：
1、首先，我们要弄清楚全排列和组合的概念，才能清楚的理解排列组合的计算公式。
2、然后，用这些基本概念去讨论排列组合的情况，得出一个公式去验证排列组合的情况是否正确。
3、接着，我们需要做出正确的推断，将基本概念和判断的概率公式综合起来，形成一个新的公式。
4、最后，用新的公式推导出排列组合的计算公式，并计算出结果。
全排列的几种实现（含字典序排列算法分析）
全排列的⼏种实现（含字典序排列算法分析） 始于⼀个很简单的问题：⽣成｛0，1，2，3，...，n-1｝的n！种排列，即全排列问题。
下⾯介绍⼏种全排列的实现，以及探讨⼀下其解题思路。
基于枚举/递归的⽅法思路： 基于枚举的⽅法，也可以说是基于递归的⽅法，此⽅法的思路是先将全排列问题的约束进⾏放松，形成⼀个较容易解决的新问题，解新问题，再对新问题进⾏约束，解出当前问题。
以上全排列问题是⽣成｛0，1，2，...，n-1｝的n！个排列，隐含的⼀个约束是这个n个位置上的数必须是给出的集合中的数，不能重复使⽤。
当我们将此约束放松的时候，问题就变成了n个位置每个位置上有0~n-1种可能出现的数字，列出所有n n种数列，即在每⼀位上枚举所有的可能。
新问题的算法⾮常简单：private Integer[] perm;private void permut(int pos, int n) {if (pos == n) {for (int i = 0; i < perm.length; i++) {System.out.print(perm[i]);}System.out.println();return;}for (int i = 0; i < n; i++) {perm[pos] = i;permut(pos+1, n);}} ⽽我们实际的问题只要保证每⼀位上的数字在其他位置上没有使⽤过就⾏了。
private boolean[] used;private Integer[] perm;private void permut(int pos, int n) {if (pos == n) {for (int i = 0; i < perm.length; i++) {System.out.print(perm[i]);}System.out.println();return;} //针对perm的第pos个位置，究竟使⽤0~n-1中的哪⼀个进⾏循环for (int i = 0; i < n; i++) {if (used[i] == false) {perm[pos] = i;used[i] = true; //i已经被使⽤了，所以把标志位设置为Truepermut(pos+1, n);used[i] = false; //使⽤完之后要把标志复位}}} 或者完全按递归是思想，对｛0，1，2，...，n-1｝进⾏排列，分别将每个位置交换到最前⾯位，之后全排列剩下的位：private static void PermutationList(int fromIndex, int endIndex){if (fromIndex == endIndex)Output();else{for (int index = fromIndex; index <= endIndex; ++index){// 此处排序主要是为了⽣成字典序全排列，否则递归会打乱字典序Sort(fromIndex, endIndex);Swap(fromIndex, index);PermutationList(fromIndex + 1, endIndex);Swap(fromIndex, index);}}}基于字典序的⽅法 基于字典序的⽅法，⽣成给定全排列的下⼀个排列，所谓⼀个的下⼀个就是这⼀个与下⼀个之间没有其他的。
算法设计与分析之全排列
将(1)中的a1,a2互换位置，得到(2); 将(1)中的a1,a3互换位置，得到(3).
可以用循环重复执行“交换位置，后跟剩余序列的所有排列”；对剩余的序列再使用该方法，直至没有剩余序列——递归调用
由排列组合的知识可知，n个元素的全排列共有n!种。 n!可分解为n*(n-1)!种，而 (n-1)!又分解为(n-1)(n-2)!种， 依次类推。
对于n个元素a=(a1a2……ak……an)， 设过程range(a, k, n)是求a的第k到第n个元素的全排列。 算法如下： procedure range(a,k,n); 当k指向最后元素时， 递归终止，输出相应的字符串a 否则 i从k到n重复执行： 交换ak与ai ; range(a, k+1, n); 交换ak与ai ; endrange;
全排列
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个数的全排列
全排列算法的生成
是一个完备的全排列生成算法，既没有遗漏，也没有重复。于是，我们想到研究 序数和其对应排列来判定某一种算法的完备性问题。 这个问题由定理 5 给出一个 彻底的解决。
定理 5：如果生成序数与排列之间的映射是一一对应，算法生成了 N！个排 列：那么此映射生成的全排列算法是完备的，反之亦然。 证明：
(充分性)如果序数和排列之间是一一对应的，那么这些排列必然没有重 复，因为重复的排列对应了相同的序数，这是矛盾的。加之，算法生成了 N！ 个排列，根据引理 2 可知，算法是完备的。充分性得证。 (必要性)如果算法是完备的，那么根据引理 1 可知，他生成的排列数为 N!。同样，由于算法是完备的，他每一个排列必然有一个生成序号，他每一 个序号一定对应一个排列。必要性得证。
引理 1：A(1，N)的全排列的总数是 N！ 证明：
使用乘法法则，在第一个位置上有 N 种选择，第二个位置上有 N-1 种选 择，依次类推：根据组合计数原理，我们得到 A(1,N) 的全排列的总数为 N*(N-1)*...1 = N!
■证毕
引理 2：如果某个全排列算法 B，对 A(1，N)所生成的全排列数为 N!,且算 法 B 并不生成任何重复排列，那么这个算法既是合法的全排列算法，也是完备 的全排列算法。 证明：
论点第三， 通过对完备全排列生成算法进行分析， 得到了依据依据序数映射建立相关的 全排列算法的表示和转换， 建立了所有的完备全排列算法的生成理论， 给出了全排列算法的 自构成性质，也就是说任何一种全排列算法都可以由另一个序列({0...n!-1})的全排列表示。 当然我们设计和使用新的全排列算法并不需要依据这种自构成性质编程， 只需要根据序数映 射的理论来编程即可。
既然算法 B 不重复，那么如果他不是完备的，他一定遗漏了某种排列， 假如他遗漏了 p 个排列，那么 A(1，N)总的排列数为 N! + p，而通过引理 1，
全排列生成算法的分析
只有三个[0,1,7]。
x 105 2
x 105 2
1.5
1.5
1
1
0.5
0.5
0 0 x 105
4
2
4
6
字典全排列生成法
0
80
2
4
6
8
x 105递 增 进 位 排 列 生 成 算 法
4
3
3
2
2
1
1
0
0
2
4
6
递减进位排列生成算法
0 8
2
4
6
8
邻位对换排列生成算法
图 3. 四种全排列算法生成的相邻排列之间相同的字符个数的直方图
从另一个角度来思考，把生成的排列全部当着一个字符串，然后来比较这些 字符串有多少个位是不同的。比如排列"123456789"和"123456879"其中"78"两个 字符的位置不一样，则认为它们有 2 个位是不同的。上面的每种算法计算的排列 结果分别与上一次计算的排列结果比较，也就是将相邻的两个中介数生成的排列 进行对比，看有多少个字符是不同的，这里可以反映出通过该算法得到的排列在 字符上的变化的情况。
进行比较。图 1 是用四种算法生成的全排列曲线。
x 108 10
9 8 7 6 5 4 3 2 1
0
8
x 10 10
9 8 7 6 5 4 3 2 1
0
1
2
3
字典全排列生成法
1
2
3
递减进位排列生成算法
4
5
x 10
4
5
x 10
x 108 10
9 8 7 6 5 4 3 2 1
四种权威全排列生成算法
#include <iostream>#include <algorithm>#include <time.h>using namespace std; //全排列生成算法void SpecifiedPrum(int a[],int n,int m);//声明函数，为求给定排列后的某个排列void FullPerm(int a[],int n);//声明函数，为求所有全排列void Example();//程序例子void Zidian1_1(int a[],int n,int m);//声明函数，字典序(基于中介数)下求给定排列后的某个排列void Zidian1_2(int a[],int n);//声明函数，字典序(基于中介数)下求所有全排列void Zidian2_1(int a[],int n,int m);//声明函数，字典序(基于相邻排列特征)下求给定排列后的某个排列void Zidian2_2(int a[],int n);//声明函数，字典序(基于相邻排列特征)下求所有全排列void Dizeng1(int a[],int n,int m);//声明函数，递增进位制数法下求给定排列后的某个排列void Dizeng2(int a[],int n);//声明函数，递增进位制数法下求所有全排列void Dijian1(int a[],int n,int m);//声明函数，递减进位制数法下求给定排列后的某个排列void Dijian2(int a[],int n);//声明函数，递减进位制数法下求所有全排列void Linwei1(int a[],int n,int m);//声明函数，邻位对换法下求给定排列后的某个排列void Linwei2(int a[],int n);//声明函数，邻位对换法下求所有全排列int main(){int a[10];int p,n,m;while(1)//循环，可以多次输入请求{cout<<"请输入所需的算法模式序号："<<endl;cout<<"0.退出程序"<<endl;cout<<"1.求给定排列后的某个排列"<<endl;cout<<"2.求所有全排列"<<endl;cout<<"3.程序输入举例"<<endl;cout<<"请输入序号：";cin>>p;if(p==0)//退出循环，结束程序break;else if (p==1)//求给定排列后的某个排列，调用函数SpecifiedPrum();{cout<<"请输入排列中元素的个数：";cin>>n;cout<<"请输入想要求多少个之后的排列：";cin>>m;cout<<"请输入初始排列：";for(int i=n-1;i>=0;i--)//输入原排列cin>>a[i];cout<<"*****************************************************************************"<<endl;SpecifiedPrum(a,n,m);}else if(p==2)//求所有全排列，调用函数FullPerm();{cout<<"请输入排列的元素个数：";cin>>n;cout<<"******************************************************************** *********"<<endl;FullPerm(a,n);}else if(p==3)//例子Example();//程序例子elsecout<<"Wrong Input!"<<endl;cout<<"******************************************************************** *********"<<endl;}}void SpecifiedPrum(int a[],int n,int m)//求给定排列后的某个排列{Zidian1_1(a,n,m);Zidian2_1(a,n,m);Dizeng1(a,n,m);Dijian1(a, n,m);Linwei1(a,n,m);}void FullPerm(int a[],int n)//求给定排列后的某个排列{Zidian1_2(a,n);Zidian2_2(a,n);Dizeng2(a,n);Dijian2(a, n);Linwei2(a,n);}void Zidian1_1(int a[],int n,int m)//字典序(基于中介数)下求给定排列后的某个排列{int b[10];int d[10];int c[10]={1,2,3,4,5,6,7,8,9};//初始化c数组用于中介数还原int sign=0;//设置溢出标志为零for (int i=n-1;i>0;i--)//生成原排列的中介数{int temp=0;for (int j=i-1;j>=0;j--)if(a[i]>a[j])temp++;b[i-1]=temp;}while(m>0)//原中介数每次加一，循环m次，求新中介数；{for(int i=0;i<n-1;i++){if(b[i]<i+1){b[i]++; break;}elseb[i]=0;if(i==n-2)//中序数相加后溢出，设标志sign为1sign=1;}m--;}for (int i=n-2;i>=0;i--)//由新中介数还原得到所求新排列的1到n-1位{int s=b[i];for (int j=0;;j++){if(c[j]!=0)s--;if (s==-1){d[i+1]=c[j];c[j]=0;break; }}}for (int i=0;i<n;i++)//求出新排列最后一位的元素if(c[i]!=0){d[0]=c[i];break;}cout<<"字典序(基于中介数)：";if(sign==1)//溢出，提示不存在排列cout<<"Not Exist!"<<endl;else//打印出新排列{for (int i=n-1;i>=0;i-- )cout<<d[i]<<' ';cout<<endl;}cout<<endl;}void Zidian1_2(int a[],int n)//字典序(基于中介数)下求所有全排列{clock_t start=clock();int b[10];int m=1;cout<<"字典序(基于中介数)："<<endl;for(int i=0;i<n;i++)//输入原排列并计算全排列的总个数m{a[i]=n-i;m=m*a[i];cout<<i+1<<' ';}cout<<endl;for (int i=n-1;i>0;i--)//生成第一个排列的中介数{int temp=0;for (int j=i-1;j>=0;j--)if(a[i]>a[j])temp++;b[i-1]=temp;}while(m>1)//原中介数每次加一，循环m-1次，求得所有排列；{int c[10]={1,2,3,4,5,6,7,8,9};//初始化c数组用于中介数还原for(int i=0;i<n-1;i++)//中介数加一得新中介数{if(b[i]<i+1){b[i]++; break;}elseb[i]=0;}for (int i=n-2;i>=0;i--)//由新中介数还原得到所求新排列的1到n-1位{int s=b[i];for (int j=0;;j++){if(c[j]!=0)s--;if (s==-1){a[i+1]=c[j];c[j]=0;break; }}}for (int i=0;i<n;i++)//求出新排列最后一位的元素if(c[i]!=0){a[0]=c[i];break;}for (int i=n-1;i>=0;i-- )//打印出新排列cout<<a[i]<<' ';cout<<endl;m--;}clock_t end=clock();cout<<endl<< "Running Time: "<<static_cast<double>(end-start)/CLOCKS_PER_SEC*1000<<"ms"<<endl;//输出运行时间cout<<endl;}void Zidian2_1(int a[],int n,int m)//字典序(基于相邻排列特征)下求给定排列后的某个排列{int b[10];for (int i=0;i<n;i++)//用数列b[]代替a[]，以保证a[]不变b[i]=a[i];int sign=0;//设置溢出标志为零while(m>0)//求下一排列，循环m次，求的所需排列{int s;for(s=1;s<n;s++)//从头到左寻找第一次下降位置，位置用s记录，跳出for循环if (b[s]<b[s-1])break;if(s==n)//溢出，设sign为1，跳出while循环{ sign=1;break;}int t=s-1;while(b[t]>b[s])//找出后缀中比a[s]大的最小数，位置用t记录t--;t=t+1;swap(b[s],b[t]);//交换a[s]和a[t]的值for(int i=0;i<s/2;i++)swap(b[i],b[s-i-1]);//将后缀子序列反转m--;//m--循环}cout<<"字典序(基于相邻排列特征)：";if(sign==1)//溢出，提示不存在排列cout<<"Not Exist!"<<endl;else//打印出新排列{for (int i=n-1;i>=0;i-- )cout<<b[i]<<' ';cout<<endl;}cout<<endl;}void Zidian2_2(int a[],int n)//字典序(基于相邻排列特征)下求所有全排列{clock_t start=clock();int m=1;cout<<"字典序(基于相邻排列特征)："<<endl;for(int i=0;i<n;i++)//输入原排列并计算全排列的总个数m{a[i]=n-i;m=m*a[i];cout<<i+1<<' ';}cout<<endl;while(m>1)//求下一排列，循环m-1次，求的所有排列{int s;for(s=1;s<n;s++)//从头到左寻找第一次下降位置，位置用s记录，跳出for循环if (a[s]<a[s-1])break;int t=s-1;while(a[t]>a[s])//找出后缀中比a[s]大的最小数，位置用t记录t--;t=t+1;swap(a[s],a[t]);//交换a[s]和a[t]的值for(int i=0;i<s/2;i++)swap(a[i],a[s-i-1]);//将后缀子序列反转for (int i=n-1;i>=0;i-- )//打印出新排列cout<<a[i]<<' ';cout<<endl;m--;//m--循环}clock_t end=clock();cout<<endl<< "Running Time: "<<static_cast<double>(end-start)/CLOCKS_PER_SEC*1000<<"ms"<<endl;//输出运行时间cout<<endl;}void Dizeng1(int a[],int n,int m)//递增进位制数法下求给定排列后的某个排列{int b[10];int c[10]={1,1,1,1,1,1,1,1,1,1};//建立数列c[]，并将所有元素初始化为1，用来求新排列int sign=0;//设置溢出标志为零for (int i=n-1;i>=0;i--)//生成原排列的中介数{int temp=0;for(int j=i-1;j>=0&&a[i]!=1;j--)//记录某个数右边比它小的数的个数，存入temp if(a[j]<a[i])temp++;if(a[i]>=2)b[a[i]-2]=temp;//将temp存入数列b[]中相应的位置}while(m>0)//原中介数每次加一，循环m次，求新中介数；{for(int i=0;i<n-1;i++){if(b[i]<i+1){b[i]++; break;}elseb[i]=0;if(i==n-2)//中序数相加后溢出，设标志sign为1sign=1;}m--;//m减一再循环}for (int i=n-2;i>=0;i--)//根据新中介数求新排列{int temp=b[i];//用以统计从低位已经遍历的值为1的个数int s=0;//相应元素应填充的位置为swhile(temp>=0)//查找填充位置s{if(c[s++]==1)temp--;}s=s-1;//s自减一c[s]=i+2;//将元素填入s位置}cout<<"递增进位制数法：";if(sign==1)//溢出，提示不存在排列cout<<"Not Exist!"<<endl;else//打印出新排列{for (int i=n-1;i>=0;i-- )cout<<c[i]<<' ';cout<<endl;}cout<<endl;}void Dizeng2(int a[],int n)//声明函数，递增进位制数法下求所有全排列{int b[10];clock_t start=clock();int m=1;cout<<"递增进位制数法："<<endl;for(int i=0;i<n;i++)//输入原排列并计算全排列的总个数m{a[i]=n-i;m=m*a[i];cout<<i+1<<' ';}cout<<endl;for (int i=n-1;i>=0;i--)//生成第一个排列的中介数{int temp=0;for(int j=i-1;j>=0&&a[i]!=1;j--)//记录某个数右边比它小的数的个数，存入temp if(a[j]<a[i])temp++;if(a[i]>=2)b[a[i]-2]=temp;//将temp存入数列b[]中相应的位置}while(m>1)//原中介数每次加一，循环m-1次，求的所有排列；{int c[10]={1,1,1,1,1,1,1,1,1,1};//建立数列c[]，并将所有元素初始化为1，用来求新排列for(int i=0;i<n-1;i++)//中介数加一{if(b[i]<i+1){b[i]++; break;}elseb[i]=0;}for (int i=n-2;i>=0;i--)//根据新中介数求新排列{int temp=b[i];//用以统计从低位已经遍历的值为0的个数int s=0;//相应元素应填充的位置为swhile(temp>=0)//查找填充位置s{if(c[s++]==1)temp--;}s=s-1;//s自减一c[s]=i+2;//将元素填入s位置}for (int i=n-1;i>=0;i-- )//打印出新排列cout<<c[i]<<' ';cout<<endl;m--;//m减一再循环}clock_t end=clock();cout<<endl<< "Running Time: "<<static_cast<double>(end-start)/CLOCKS_PER_SEC*1000<<"ms"<<endl;//输出运行时间cout<<endl;}void Dijian1(int a[],int n,int m)//递减进位制数法下求给定排列后的某个排列{int b[10];int c[10]={1,1,1,1,1,1,1,1,1,1};//建立数列c[]，并将所有元素初始化为1，用来求新排列int sign=0;//设置溢出标志为零for (int i=n-1;i>=0;i--)//生成原排列的中介数{int temp=0;for(int j=i-1;j>=0&&a[i]!=1;j--)//记录某个数右边比它小的数的个数，存入temp if(a[j]<a[i])temp++;if(a[i]>=2)b[n-a[i]]=temp;//将temp存入数列b[]中相应的位置}while(m>0)//原中介数每次加一，循环m次，求新中介数；{for(int i=0;i<n-1;i++){if(b[i]<n-i-1){b[i]++; break;}elseb[i]=0;if(i==n-2)//中序数相加后溢出，设标志sign为1sign=1;}m--;//m减一再循环}for (int i=0;i<n-1;i++)//根据新中介数求新排列{int temp=b[i];//用以统计从低位已经遍历的值为1的个数int s=0;//相应元素应填充的位置为swhile(temp>=0)//查找填充位置s{if(c[s++]==1)temp--;}s=s-1;//s自减一c[s]=n-i;//将元素填入s位置}cout<<"递减进位制数法：";if(sign==1)//溢出，提示不存在排列cout<<"Not Exist!"<<endl;else//打印出新排列{for (int i=n-1;i>=0;i-- )cout<<c[i]<<' ';cout<<endl;}cout<<endl;}void Dijian2(int a[],int n)//递减进位制数法下求所有全排列{int b[10];clock_t start=clock();int m=1;cout<<"递减进位制数法："<<endl;for(int i=0;i<n;i++)//输入原排列并计算全排列的总个数m{a[i]=n-i;m=m*a[i];cout<<i+1<<' ';}cout<<endl;for (int i=n-1;i>=0;i--)//生成原排列的中介数{int temp=0;for(int j=i-1;j>=0&&a[i]!=1;j--)//记录某个数右边比它小的数的个数，存入temp if(a[j]<a[i])temp++;if(a[i]>=2)b[n-a[i]]=temp;//将temp存入数列b[]中相应的位置}while(m>1)//原中介数每次加一，循环m-1次，求的所有排列；{int c[10]={1,1,1,1,1,1,1,1,1,1};//建立数列c[]，并将所有元素初始化为1，用来求新排列for(int i=0;i<n-1;i++)//中介数加一{if(b[i]<n-i-1){b[i]++; break;}elseb[i]=0;}for (int i=0;i<n-1;i++)//根据新中介数求新排列{int temp=b[i];//用以统计从低位已经遍历的值为0的个数int s=0;//相应元素应填充的位置为swhile(temp>=0)//查找填充位置s{if(c[s++]==1)temp--;}s=s-1;//s自减一c[s]=n-i;//将元素填入s位置}for (int i=n-1;i>=0;i-- )cout<<c[i]<<' ';cout<<endl;m--;//m减一再循环}clock_t end=clock();cout<<endl<< "Running Time: "<<static_cast<double>(end-start)/CLOCKS_PER_SEC*1000<<"ms"<<endl;//输出运行时间cout<<endl;}void Linwei1(int a[],int n,int m)//邻位对换法下求给定排列后的某个排列{int b[10]={0};//建立数列b[]，并初始化所有元素为零，这样可以使求元素2时对应的中介数一般化，不用单独考虑int c[10]={1,1,1,1,1,1,1,1,1,1};//建立数列c[]，并将所有元素初始化为1，用来求新排列int sign=0;//设置溢出标志为零for (int i=2;i<=n;i++)//生成原排列的中介数{int s=0;while(a[s]!=i)//遍历a[]找出i的位置存于ss++;int temp;//方向指示数，奇右偶左if(i%2==0)//i为偶数temp=b[n-i+2]+b[n-i+1];else//i为奇数temp=b[n-i+1];int t=0;//背向i方向上，小于i的数的个数设为tif(temp%2==0)//指示数为偶数{for (int j=0;j<s;j++)//i右边比i小的数的个数if(a[j]<i)t++;}else//指示数为奇数{for (int j=n-1;j>s;j--)//i左边比i小的数的个数if(a[j]<i)t++;}b[n-i]=t;}while(m>0)//原中介数每次加一，循环m次，求新中介数；{for(int i=0;i<n-1;i++){if(b[i]<n-i-1){b[i]++; break;}elseb[i]=0;if(i==n-2)//中序数相加后溢出，设标志sign为1sign=1;}m--;//m减一再循环}for (int i=0;i<n-1;i++)//根据新中介数求新排列{int t;//方向指示数，奇右偶左if ((n-i)%2!=0)t=b[i+1];elset=b[i+1]+b[i+2];int temp=b[i];//用以统计从低位已经遍历的值为1的个数int s;//相应元素应填充的位置为sif(t%2==0)//t为偶，方向向左{s=0;//s为零while(temp>=0)//查找填充位置sif(c[s++]==1)temp--;s=s-1;//s自减一c[s]=n-i;//将元素填入s位置}else//方向向右{s=n-1;while(temp>=0)//查找填充位置sif(c[s--]==1)temp--;s=s+1;//s自减一c[s]=n-i;//将元素填入s位置}}cout<<"邻位对换法：";if(sign==1)//溢出，提示不存在排列cout<<"Not Exist!"<<endl;else//打印出新排列{for (int i=n-1;i>=0;i-- )cout<<c[i]<<' ';cout<<endl;}}void Linwei2(int a[],int n)//声明函数，邻位对换法下求所有全排列{int b[10]={0};//建立数列b[]，并初始化所有元素为零，这样可以使求元素2时对应的中介数一般化，不用单独考虑clock_t start=clock();int m=1;cout<<"邻位对换法："<<endl;for(int i=0;i<n;i++)//输入原排列并计算全排列的总个数m{a[i]=n-i;m=m*a[i];cout<<i+1<<' ';}cout<<endl;for (int i=2;i<=n;i++)//生成原排列的中介数{int s=0;while(a[s]!=i)//遍历a[]找出i的位置存于ss++;int temp;//方向指示数，奇右偶左if(i%2==0)//i为偶数temp=b[n-i+2]+b[n-i+1];else//i为奇数temp=b[n-i+1];int t=0;//背向i方向上，小于i的数的个数设为tif(temp%2==0)//指示数为偶数{for (int j=0;j<s;j++)//i右边比i小的数的个数if(a[j]<i)t++;}else//指示数为奇数{for (int j=n-1;j>s;j--)//i左边比i小的数的个数if(a[j]<i)t++;}b[n-i]=t;}while(m>1)//原中介数每次加一，循环m次，求的所有排列；{int c[10]={1,1,1,1,1,1,1,1,1,1};//建立数列c[]，并将所有元素初始化为1，用来求新排列for(int i=0;i<n-1;i++)//中介数加一{if(b[i]<n-i-1){b[i]++; break;}elseb[i]=0;}for (int i=0;i<n-1;i++)//根据新中介数求新排列{int t;//方向指示数，奇右偶左if ((n-i)%2!=0)t=b[i+1];elset=b[i+1]+b[i+2];int temp=b[i];//用以统计从低位已经遍历的值为1的个数int s;//相应元素应填充的位置为sif(t%2==0)//t为偶，方向向左{s=0;//s为零while(temp>=0)//查找填充位置sif(c[s++]==1)temp--;s=s-1;//s自减一c[s]=n-i;//将元素填入s位置}else//方向向右{s=n-1;while(temp>=0)//查找填充位置sif(c[s--]==1)temp--;s=s+1;//s自减一c[s]=n-i;//将元素填入s位置}}for (int i=n-1;i>=0;i-- )cout<<c[i]<<' ';cout<<endl;m--;//m减一再循环}clock_t end=clock();cout<<endl<< "Running Time: "<<static_cast<double>(end-start)/CLOCKS_PER_SEC*1000<<"ms"<<endl;//输出运行时间}void Example(){cout<<"*Example: "<<endl;cout<<"请输入所需的算法模式序号："<<endl;cout<<"0.退出程序"<<endl;cout<<"1.求给定排列后的某个排列"<<endl;cout<<"2.求所有全排列"<<endl;cout<<"3.程序输入举例"<<endl;cout<<"请输入序号：1"<<endl;cout<<"请输入排列中元素的个数：5"<<endl;cout<<"请输入想要求多少个之后的排列：100"<<endl;cout<<"请输入初始排列：1 2 3 4 5"<<endl;cout<<"******************************************************************** *********"<<endl;cout<<"字典序(基于中介数)：5 1 4 2 3"<<endl<<endl;cout<<"字典序(基于相邻排列特征)：5 1 4 2 3"<<endl<<endl;cout<<"递增进位制数法：5 3 1 2 4"<<endl<<endl;cout<<"递减进位制数法：3 2 1 4 5"<<endl<<endl;cout<<"邻位对换法：4 2 1 3 5"<<endl;}。
组合数学中的全排列生成算法完整版
组合数学全排列生成算法组合数学中的全排列深成算法历来是组合数学考试的重要考察点，因此在这里我简单的介绍一下6种全排列生成算法的详细过程，并借此比较它们之间的优劣之处。
不论是哪种全排列生成算法，都遵循着“原排列”→“原中介数”→“新中介数”→“新排列”的过程。
其中中介数依据算法的不同会的到递增进位制数和递减进位制数。
关于排列和中介数的一一对应性的证明我们不做讨论，这里仅仅给出了排列和中介数的详细映射方法。
相信熟练掌握了方法就可以顺利通过这部分的考察。
递增进位制和递减进位制数所谓递增进位制和递减进位制数字是指数字的进制随着数字位置的不同递增或递减。
通常我们见到的都是固定进制数字，如2进制，10进制等。
m位n进制数可以表示的数字是m*n个。
而m位递增或递减进位制数则可以表示数字m!个。
例如递增进位制数4121，它的进制从右向左依次是2、3、4、5。
即其最高位（就是数字4那位）最大值可能是4；第三高位最大可能是3；第二高位最大可能是2；最末位最大可能是1。
如果将4121加上1的话，会使最末位得到0，同时进位；第二位的2与进位相加，也会得到0，同时进位；第三位的1与进位相加得到2，不再进位。
最终得到结果是4200。
递减进位制的道理是一样的，只不过进制从右向左依次是9、8、7、6……，正好与递增进位制相反。
很明显，递减进位制的一个最大的好处就是加法不易进位，因为它在进行加法最频繁的末几位里（最右边）进制比较大。
接下来要了解的是递增进位制、递减进位制数和其序号的关系。
递增、递减进位制数可以被看作一个有序的数字集合。
如果规定递增进位制和递减进位制数的0的序号是十进制0，递增进位制数的987654321和递减进位制数的123456789对应十进制序号362880（即9!），则可以整理一套对应法则。
其中，递增进位制数（a1 a2 a3 a4 a5 a6 a7 a8 a9）为：a1*9! + a2*8! + ….+ a8*2! + a9*1! =序号例如序号100的递增进位制数就是4020，即4*4！+ 0*3！+ 2*2！+ 0*1！=100。
全排列算法解析(完整版)
void Permutation(int A[], int m, int n) {
int i, int temp; if(m = = n)
{ for(i = 0;i<n;i++) { if(i != n-1) printf("%d ",A[i]); //有加空格 else printf("%d" A[i]); //没加空格 } //直接输出，因为前 n-1 个数已经确定，递归到只有 1 个数。 printf("\n"); return;
1.5 组合数学之全排列的生成算法
Yiqiang Wei <weiyiqiang@>
1.5.1字典序法
方法2-1：
由72642321推算出839647521 中介数右端加一个 0扩成0 9位，先定 1，每定 72642321中未出现 ，1在最右边 一位，其左边未定位下加一点，从（位－ 位下点数=0）的位中选最左的。
=279905
Yiqiang Wei <weiyiqiang@>
1.5.2递增进位制数法 由(anan-1…a2)↑求p1p2…pn。
从大到小求出n,n-1,…,2,1的位置 _ ... _ n _ _ …_
\______ ______/ V
an个空格 n的右边有an个空格。 n-1的右边有an-1个空格。 ………… 2的右边有a2个空格。 最后一个空格就是1的位置。
83964752 1 726423210
● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●
2 的位置 3 4 5 6 7 8 9 定 1
Yiqiang Wei <weiyiqiang@>
1.5.1字典序法
方法2-2：
由72642321推算出839647521 已定出上标‘●’，找左起第一个0，下标‘__’
※※ 两个字符串，相同前缀越长的越靠近。
Yiqiang Wei <weiyiqiang@>
1.5 全排列的生成算法
如何生成给定全排列的下一个排列 所谓一个的下一个就是这一个与下一个之间没有 其他的。这就要求这一个与下一个有尽可能长 的共同前缀，也即变化限制在尽可能短的后缀 上。 例如 839647521是1--9的排列。1—9的排列最前 面的是123456789，最后面的是987654321，从 右向左扫描若都是增的，就到了987654321，也 就没有下一个了。否则找出第一次出现下降的 位置。
全排列（递归算法）
全排列（递归算法）⼀．全排列算法⾸先：什么是全排列=》百度⼀下从n个不同元素中任取m（m≤n）个元素，按照⼀定的顺序排列起来，叫做从n个不同元素中取出m个元素的⼀个排列。
当m=n时所有的排列情况叫全排列。
公式：全排列数f(n)=n!(定义0!=1)算法：递归算法=》⽹络上偷了⼀个图全排列：顺便复习⼀个数学公式排列的定义：从n个不同元素中，任取m(m≤n,m与n均为⾃然数,下同）个元素按照⼀定的顺序排成⼀列，叫做从n个不同元素中取出m个元素的⼀个排列；从n个不同元素中取出m(m≤n）个元素的所有排列的个数，叫做从n个不同元素中取出m个元素的排列数，⽤符号 A(n,m）表⽰。
计算公式：组合的定义：从n个不同元素中，任取m(m≤n）个元素并成⼀组，叫做从n个不同元素中取出m个元素的⼀个组合；从n个不同元素中取出m(m≤n）个元素的所有组合的个数，叫做从n个不同元素中取出m个元素的组合数。
⽤符号 C(n,m) 表⽰。
计算公式：；C(n,m)=C(n,n-m）。
（n≥m)排列和组合的区别：看问题是否和顺序有关。
有关就是排列，⽆关就是组合。
排列：⽐如说排队问题甲⼄两⼈排队，先排甲，那么站法是甲⼄，先排⼄，那么站法⼄甲，是两种不同的排法，和先排还是后排的顺序有关，所以是A(2,2)=2种组合：从甲⼄两个球中选2个，⽆论先取甲，在是先取⼄，取到的两个球都是甲和⼄两个球，和先后取的顺序⽆关，所以是C(2,2)=1种#include<iostream>using namespace std;//交换void swap(int &a , int &b){int temp;temp = a;a = b;b = temp;}//全排列递归算法void Perm(int list[] , int k ,int m){//list 数组存放排列的数，K表⽰层代表第⼏个数，m表⽰数组的长度if(k==m){//K==m 表⽰到达最后⼀个数，不能再交换，最终的排列的数需要输出；for(int i=0 ;i<=m ;i++)cout<<list[i];cout<<endl;}else{for(int i=k;i<=m;i++){swap(list[i],list[k]);Perm(list,k+1,m);swap(list[i] , list[k]);}}}int main(void){int a[]={1,2,3};int m=2;Perm(a,0,2);/*123132213231321312*/}算法解析思路树解释每次固定⼏位数，最后只剩⼀位数，输出，在从后⾯递归返回上⼀层，交换在输出for(int i=k;i<=m;i++){swap(list[i],list[k]);Perm(list,k+1,m);swap(list[i] , list[k]);}代码解析”” int i=k K表⽰固定了⼏位数，当前数组交换的临界的位置1,2,3,4 当K=0的时候 {1,2,3,4} =》1是固定的 K+1递归{1}p{2,3,4}，K=1，I=1 数组交换只能list[1],list[2],list[3]交换 k=i ,就是为了作为⼀个标识。
排列组合生成算法
全排列生成算法
全排列生成算法
全排列生成算法是指，在计算机算法领域，使用一组有限个数的元素，按照一定的顺序排列出所有可能的排列组合，这种算法的应用非常广泛。
它通常应用在诸如有限的搜索空间有限的排列搜索，模拟和调度系统中，如模拟多核心交叉编程和利用资源安排调度程序等，而在互联网领域，全排列生成算法得到了广泛的运用。
首先，全排列生成算法可以将URL地址和关键词进行排列组合，构建出多种搜索语义，帮助用户更好、更快地获取需要的资料，进而提高搜索效率，极大的提升了用户的搜索体验，也减轻了后端的搜索计算压力。
此外，在互联网推广项目中，也能用全排列生成算法对网站的多元素构建，来减少网站页面广告群体和PV、UV背后被推广页面之间的数量差异，有效提高推广项目的效率、投入产出比，进一步影响经济效益。
总之，全排列生成算法的应用范围很广，在互联网领域得到了广泛的应用和发挥，可以说有着重要的作用。
它可以极大的提高互联网用户的搜索体验和互联网推广的效益，也可以减轻后端的搜索计算压力，同时用户也可以获得更快速、更准确的搜索结果。
组合数学第4章[生成排列与组合]PPT教学课件
![组合数学第4章[生成排列与组合]PPT教学课件](https://img.taocdn.com/s3/m/3730f42819e8b8f67d1cb97c.png)
2020/12/10
14
§4.2 生成组合
生成组合
4.2.1 基2算法 若S是n个元素的集合，元素为{xn-1,...,x1,x0}， 则生成组合就是生成S的所有2n个子集。 任一子集可以描述成：
(an-1,...,a1,a0)=an-1...a1a0 其中，ai为1或0，表示xi在或不在子集中。
于是S的全部子集可以用0~2n-1的整数来描 述，只要生成这些整数，也就得到了所有组合。
其中，0表示空集，2n-1表示S本身。
全排列生 成算法
2020/12/10
6
3. 直接生成全排列的算法
全排列生 成算法
[定义]对排列中的每个元素k，赋予其一
个方向：k 或 k 。如果一个整数k的箭头 指向一个与其相邻但比它小的整数，则
称k是活动的。
例如，对于：263154
只有6、3、5是活动的。
2020/12/10
7
显然：
全排列生 成算法
a1+a2+...+an 度量了排列的无序程度。
2020/12/10
11
全排列生
[例]31524的逆序列是1,2,0,1,0。 成算法
[结论]对于逆序列，显然有0≤ak≤n-k。且 任何一个排列都可确定一个逆序列。
[定理]若b1,b2,...,bn是满足0≤bk≤n-k的整数 序列，则存在{1,2,...,n}的唯一的一个排 列，其逆序列为b1,b2,...,bn 。
21
2020/12/10
4
{1,2,3}的排列
全排列生
1 2 3 成算法 2 31 31 2 32 1 13 2 2 13
2020/12/10
5
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
全排列的生成算法对于给定的字符集，用有效的方法将所有可能的全排列无重复无遗漏地枚举出来。
字典序法按照字典序求下一个排列的算法 /*例字符集{1,2,3},较小的数字较先,这样按字典序生成的全排列是:123,132,213,231,312,321。
注意一个全排列可看做一个字符串，字符串可有前缀、后缀。
*/生成给定全排列的下一个排列所谓一个全排列的下一个排列就是这一个排列与下一个排列之间没有其他的排列。
这就要求这一个排列与下一个排列有尽可能长的共同前缀，也即变化限制在尽可能短的后缀上。
/*例是1—9的排列。
1—9的排列最前面的是，最后面的是，从右向左扫描若都是增的，就到了，也就没有下一个了。
否则找出第一次出现下降的位置。
算法: 由P1P2…Pn 生成的下一个排列的算法如下:1. 求i=max{j| Pj-1<Pj}2. 求l=max{k| Pi-1<Pk }3. 交换Pi-1 与Pl得到P1P2…Pi-1 (P i....Pn ) , 将红色部分顺序逆转,得到结果. 例求的下一个排列1. 确定i，从左到右两两比较找出后一个数比前一个大的组合，在这里有39 47，然后i取这些组中最到的位置号（不是最大的数）在这两组数中7的位置号最大为6，所以i=62.确定l，找出在i（包括i）后面的所有比i前面那一位大的数的最大的位置号，在此例中7，5 都满足要求，则选5，5的位置号为7，所以 l=73. 先将4和5交换，然后将5后的四位数倒转得到结果à以上算法是在数论课上老师给出的关于字典序全排列的生成算法，以前也经常要用到全排列生成算法来生成一个全排列对所有的情况进行测试，每次都是现到网上找一个算法，然后直接copy代码，修改一下和自己的程序兼容就行了，也不看是怎么来的，不是我不想看，实在是说的很抽象，那一大堆公式来吓人，一个实例都不给，更有甚者连算法都没有，只是在那里说，想看都看不懂，也没那个耐心取理解那些人写出来的那种让人无法忍受的解释。
不过在说别人的同时我也知道，自己写的也不够好，不过这就是我的理解了，没法子写的再细了。
全排列的生成算法2008年04月25日星期五下午03:23全排列的生成算法就是对于给定的字符集，用有效的方法将所有可能的全排列无重复无遗漏地枚举出来。
任何n个字符集的排列都可以与1～n的n个数字的排列一一对应，因此在此就以n个数字的排列为例说明排列的生成法。
n个字符的全体排列之间存在一个确定的线性顺序关系。
所有的排列中除最后一个排列外，都有一个后继；除第一个排列外，都有一个前驱。
每个排列的后继都可以从它的前驱经过最少的变化而得到，全排列的生成算法就是从第一个排列开始逐个生成所有的排列的方法。
全排列的生成法通常有以下几种：字典序法递增进位数制法递减进位数制法邻位交换法n进位制法递归类算法1.字典序法字典序法中，对于数字1、2、3......n的排列，不同排列的先后关系是从左到右逐个比较对应的数字的先后来决定的。
例如对于5个数字的排列12354和12345，排列12345在前，排列12354在后。
按照这样的规定，5个数字的所有的排列中最前面的是12345，最后面的是54321。
字典序算法如下：设P是1～n的一个全排列:p=p1p2......pn=p1p2......pj-1pjpj+1......pk-1pkpk+1......pn1）从排列的右端开始，找出第一个比右边数字小的数字的序号j（j从左端开始计算），即j=max{i|pi<pi+1} 2）在pj的右边的数字中，找出所有比pj大的数中最小的数字pk，即k=max{i|pi>pj}（右边的数从右至左是递增的，因此k是所有大于pj的数字中序号最大者）3）对换pi，pk4）再将pj+1......pk-1pkpk+1pn倒转得到排列p'=p1p2.....pj-1pjpn.....pk+1pkpk-1.....pj+1，这就是排列p的下一个下一个排列。
例如是数字1～9的一个排列。
从它生成下一个排列的步骤如下：自右至左找出排列中第一个比右边数字小的数字4在该数字后的数字中找出比4大的数中最小的一个5将5与4交换将7421倒转所以的下一个排列是。
程序代码如下：Private Sub Dict(p() As Integer, ByVal n As Integer)Dim i As Integer, j As IntegerOutL pi = n - 1Do While i > 0If p(i) < p(i + 1) ThenFor j = n To i + 1 Step -1 '从排列右端开始If p(i) <= p(j) Then Exit For '找出递减子序列NextSwap p(i), p(j) '将递减子序列前的数字与序列中比它大的第一个数交换For j = n To 1 Step -1 '将这部分排列倒转i = i + 1If i >= j Then Exit For2Swap p(i), p(j)NextOutL p '输出一个排列i = nEnd Ifi = i - 1LoopEnd SubSwap p(i), p(j)是交换两个元素的子过程，OutL p是输出排列的子过程。
2.递增进位数制法在递增进位制数法中，从一个排列求另一个排列需要用到中介数。
如果用ki表示排列p1p2...pi...pn中元素pi的右边比pi小的数的个数，则排列的中介数就是对应的排列k1 ...... ki...... kn-1。
例如排列的中介数是，7、2、6、......分别是排列中数字8、3、9、......的右边比它小的数字个数。
中介数是计算排列的中间环节。
已知一个排列，要求下一个排列，首先确定其中介数，一个排列的后继，其中介数是原排列中介数加1，需要注意的是，如果中介数的末位kn-1+1=2，则要向前进位，一般情形，如果ki+1=n-i+1，则要进位，这就是所谓的递增进位制。
例如排列的中介数是，则下一个排列的中介数是+1=（因为1+1=2，所以向前进位，2+1=3，又发生进位，所以下一个中介数是）。
得到中介数后，可根据它还原对应得排列。
算法如下：中介数k1、k2、......、kn-1的各位数字顺序表示排列中的数字n、n-1、......、2在排列中距右端的的空位数，因此，要按k1、k2、......、kn-1的值从右向左确定n、n-1、......、2的位置，并逐个放置在排列中：i放在右起的ki+1位，如果某位已放有数字，则该位置不算在内，最后一个空位放1。
因此从可得到排列，它就是的后一个排列。
因为9最先放置，k1=6，9放在右起第7位，空出6个空位，然后是放8，k2=7，8放在右起第8位，但9占用一位，故8应放在右起第9位，余类推。
程序代码如下：Private Sub Incr(p() As Integer, ByVal n As Integer)Dim m() As Integer '保存中介数的数组Dim i As Integer, j As IntegerDim a As IntegerReDim m(n)For i = 1 To n '第一个排列的中介数为000 0m(i) = 0NextDo While n > 0For i = 1 To n '排列的各位为0p(i) = 0NextFor i = 1 To n '从右向左察看排列中为0的位a = m(i) + 1j = nDo While j > 0If p(j) = 0 Thena = a - 1If a = 0 Then Exit Do '0的个数决定数字i的位置End Ifj = j - 1Loopp(j) = n - i + 1 '将数字i放置在指定位置NextOutL pIf MedN(m) Then Exit Do '计算下一个中介数，如果是00...0，则全部排列找到LoopEnd SubPrivate Function MedN(m() As Integer)As Boolean '计算中介数函数Dim i As Integer, sum As IntegerDim b As Booleanb = Falsei = n - 1Do While i > 0m(i) = m(i) + 1If m(i) < n - i + 1 Then Exit Dom(i) = 0i = i - 1LoopSum = 0For i = 1 To n - 1 '计算中介数各位之和Sum = Sum + m(i)NextIf Sum = 0 Then b = True '中介数各位之和为0MedN = b4End Function3.递减进位制数法在递增进位制数法中，中介数的最低位是逢2进1，进位频繁，这是一个缺点。
把递增进位制数翻转,就得到递减进位制数。
的中介数是(k1k2…kn-1)，倒转成为(kn-1…k2k1)，这是递减进位制数的中介数：ki(i=n-1,n-2,…,2)位逢i向ki-1位进1。
给定排列p，p的下一个排列的中介数定义为p的中介数加1。
例如p=，p 的中介数为，p的下一个排列的中介数为+1=，由此得到p的下一个排列为。
给定中介数，可用与递增进位制数法类似的方法还原出排列。
但在递减进位制数中，可以不先计算中介数就直接从一个排列求出下一个排列。
具体算法如下：1）如果p(i)=n且i<>n，则p(i)与p(i-1)交换2）如果p(n)=n，则找出一个连续递减序列9、8、......、i，将其从排列左端删除，再以相反顺序加在排列右端，然后将i-1与左边的数字交换例如p=的下一个排列是。
求的下一个排列时，因为9在最左边且第2位为8，第3位不是7，所以将8和9从小到大排于最右端，再将7与其左方数字对调得到的下一个排列是。
又例如求的下一个排列，只需要将9876从小到大排到最右端并将5与其左方数字3对调，得到。
程序代码如下：Private Sub Degr(p() As Integer, ByVal n As Integer)Dim i As Integer, j As IntegerDo While n > 0OutL pIf p(1) = n Then '如果第一位是ni = 0Do '从左端开始找出最长的连续递降序列i = i + 1If i = n Then Exit SubLoop Until p(i) <> p(i + 1) + 1j = iDo '找出递降序列末尾数字的下一个数字i = i + 1Loop Until p(i) = p(j) - 1Swap p(i), p(i - 1) '将它与序列末尾数字交换For i = 1 To n - j '将递减序列倒转后放置在排列右端p(i) = p(i + j)NextFor i = 1 To jp(n - i + 1) = n - i + 1NextElse '如果最高位不是ni = 0 '从左端开始Do '找出n所在位置i = i + 1Loop Until p(i) = nSwap p(i), p(i - 1) '将n与其左边数字交换End IfLoopEnd Sub4.邻位对换法邻位对换法中下一个排列总是上一个排列某相邻两位对换得到的。