【排列组合】有序进行全排列的几种方法

一. 所谓有序的全排列

如输入不同的数字使其排列后从小到大顺序输出，如：

123

则可以输出如下组合

1 2 3

1 3 2

2 1 3

2 3 1

3 1 2

3 2 1

共六种情况

后面将问题简化一下，输入1-9代表不同的数字1~9，如输入4则对1234进行排序。

二. 有序全排列的思路

1. 数学法

观察a1,a2,a3,...,an的排列情况，假设我需要第k个排列结果。（注意:a1<a2<a3<...<an)

如果第一个元素a1不需要交换，一共有(n-1)!种排列，当k>(n-1)!时，第一个元素必定不是a1了，那会是哪个元素呢？

以这个元素为开头的排列排列序号a11~(n-1)!a2(n-1)!+1~2*(n-1)!an(n-1)*(n-1)!+1~n!那么一直求第k个序号的排列，就可以确定第一个元素是多少；

确定第一个元素后，下一层每个元素的范围则缩小到(n-2)!，而问题与上述无异，也就是说，可以利用这种规律，逐个元素求出这个排列。

假设数串为1234，总共有4!=24种排列情况，求第15种排列结果。

第一个元素则为[(15-1)/3!]+1=3，取1234中的第三个作为a1，k=15-6*2=3，未用元素为124

第二个元素则为[(3-1)/2!]+1=2，取124中的第二个作为a2，k=3-2*1=1，未用元素为14

由于为1，所以剩余的则为14顺序

结果为3214

我们按顺序写一下，确保准确无误

123412431324134214231432213421432314234124132431312431423214324134123421412341324213423143124321123456789101112131415161718192021222324

那么我们用代码把它实现即可（当然，你的实现方法可能更好，因为是很久前写的，将就着看吧）

#include <stdio.h>#include <stdlib.h>#include <string.h>int find_kth_element(int n, int kth, int **ans){int *used;int jiecheng, k, temp, ntemp=n, kk;for(k=1, jiecheng=1; k<n-1; k++){jiecheng *= (k+1);}used = (int*)malloc(sizeof(int)*n);*ans = (int*)malloc(sizeof(int)*n);memset(used, 0, sizeof(int)*n);for(k=0; k<n; k++){*(*ans+k) = k;}if(kth>jiecheng*n)return -1;n--; k=0; kth--;while(1){if(kth==0){for(; k<ntemp; k++){kk=0;while(used[kk++]!=0);used[kk-1] = 1;*(*ans+k) = kk-1;}break;}temp=kth/jiecheng;kk=0;do{while(used[kk++]!=0);temp--;}while(temp>=0);*(*ans+k) = kk-1;used[kk-1]=1;kth = kth%jiecheng;jiecheng = jiecheng/n;n--; k++;}//free(used);return 0;}int main(void){int n, kth;int *num, k, *ans=NULL;printf("n="); scanf("%d", &n);printf("kth="); scanf("%d", &kth);num = (int*)malloc(sizeof(int)*n);for(k=0; k<n; k++){*(num+k) = k+1;}find_kth_element(n, kth, &ans);for(k=0; k<n; k++){printf("%d", *(num+*(ans+k)));}system("pause");return 0;}

2. 逐层排列法

思路：每层元素交换互不干扰的原则，每层第一个元素与第一个元素、第二个元素。。。交换元素，并保存该层交换结果，直至交换到第n个元素。

以1234为例

第一层为1234  位置1与位置1的元素交换(后面简写成1<->1)，得到1234，进入第二层(234)， 1<->1，得到234，进入第三层(23)，1<->1，得到34， 进入第四层(4)，1<->1，得到4，所以，第一个排列结果为1234；

第四层继续交换，1<->2，超出元素个数，返回第三层(34)，1<->2，得到43，同样进入第四层(3)，。。。得到第二个排列结果为1243；

第四层继续交换，1<->2，超出元素个数，返回第三层(43)，1<->3，超出元素个数，返回第二层(234)，1<->2，得到324，然后进入第三层(24)。。。得到第三个排列结果1324，紧接着是1342；

在退回第二层(324)，当时记录结果是324，那么现在要1<->3，得到423，再进入第三层(23)，依次得到1423  1432；

退回第二层，此时1<->4，超出元素个数，返回第一层(1234)，1<->2，得到2134，进入第二层(134)，从1<->1开始排列，依次得到2134  2143  2314  2341  2413  2431；

返回第一层(2134)，1<->3，得到3124，然后依次得到2134  2143  2314  2341  2413  2431

返回第一层(3124)，1<->4，得到4123，然后依次得到4123  4132  4213  4231  4312  4321

这样得到了全排列。

#include <stdio.h>#include <stdlib.h>#include <string.h>static int sts=0;void dis_num(int *num, int n){int k;printf("%d: ", sts);for(k=0; k<n; k++){printf("%d ", *(num+k));}printf("\n");}void quanpailie(int *num, int k, int n){ //按层进行全排列，一层交换方法 1 2 3 4->2 1 3 4->3 1 2 4->4 1 2 3 第一个元素逐个向后交换，然后再对第二位之后的数据进行全排列//num:原数字序列，k:从第几个元素开始对调，n:数字序列数字个数int *newnum;int kk, temp;if(k>=n){++sts;dis_num(num, n);return;}newnum = (int*)malloc(sizeof(int)*n);memcpy(newnum, num, sizeof(int)*n);  //不恢复序列就是从小到大，一层交换例子 1 2 3 4->2 1 3 4->3 1 2 4->4 1 2 3//-------->问题代码，全排列结果非从小到大for(kk=k; kk<n; kk++){//memcpy(newnum, num, sizeof(int)*n);  //恢复序列，交换下一个元素，这个放的位置不一样，结果就不同temp = newnum[k];newnum[k] = newnum[kk];newnum[kk] = temp;quanpailie(newnum, k+1, n);   //交换后，元素k后面的元素进行全排列}}int main(void){int n, k;int *num;printf("n="); scanf("%d", &n);if(n<1&&n>9)return 0;num = (int*)malloc(sizeof(int)*n);for(k=0; k<n; k++){*(num+k) = k+1;}quanpailie(num, 0, n);system("pause");return 0;}

3.局部排序

规律：
在当前序列中，从尾端往前寻找两个相邻元素，前一个记为*i，后一个记为*ii，并且满足*i < *ii。然后再从尾端寻找另一个元素*j，如果满足*i < *j，
即将第i个元素与第j个元素对调，并将第ii个元素之后（包括ii）的所有元素颠倒排序，即求出下一个序列了。
比如：12345开始组合排列，12354,12435,...,12543,在12位置不变情况下，最大组合情况为12543，然后，比2略大的数必定在从后向前搜索到的第一个数,所以改为13542,此时需要从最小组合开始，对542进行排序，得到结果13245；
又当13位置不变，其最大为13542，向后搜索到比3大的为4，则改为14532，然后对4之后的数排序，的14235. 排序复杂度决定这个算法复杂度。

#include <stdio.h>#include <stdlib.h>int find(int *d, int n, int *i, int *ii, int *j){int k;for(k=n-1; k>=1; k--){if(*(d+k-1)<*(d+k)){*i=k-1;*ii=k;break;}}if(k==0)return -1;for(k=n-1; k>=0; k--){if(*(d+*i)<*(d+k)){*j = k;break;}}return 0;}int partition(int *d, int low, int high){int temp;while(low<high){while(low<high&&*(d+low)<=*(d+high)) high--;temp = *(d+low);*(d+low) = *(d+high);*(d+high) = temp;while(low<high&&*(d+high)>=*(d+low)) low++;temp = *(d+low);*(d+low) = *(d+high);*(d+high) = temp;}return low;}void quick_sort(int *d, int low, int high){int mid;if(low<high){mid = partition(d, low, high);quick_sort(d, low, mid-1);quick_sort(d, mid+1, high);}}void display_full_array(int *d, int n){int k;int i, ii, j;int temp;while(1){for(k=0; k<n; k++){printf("%d", *(d+k));}printf("\n");if(find(d, n, &i, &ii, &j)==-1)break;temp = *(d+i);*(d+i) = *(d+j);*(d+j) = temp;quick_sort(d, ii, n-1);}}int main(void){int n;int *d, k;scanf("%d", &n);if(n>0&&n<10){d = (int*)malloc(sizeof(int)*n);for(k=0; k<n; k++){*(d+k) = k+1;}}elsereturn 0;display_full_array(d, n);system("pause");return 0;}