fullpermutation

最新推荐文章于 2020-02-18 19:46:44 发布
最新推荐文章于 2020-02-18 19:46:44 发布
阅读量728 收藏
点赞数
分类专栏： 递归算法 文章标签： permutation
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qianlizhima1/article/details/8287952
版权 
/*
 * szlFullPermutation.h
 */
 
#ifndef SZL_FULLPERMUTATION_H
#define SZL_FULLPERMUTATION_H

 typedef char* STR;
 typedef char** PSTR;

 void fullPermutation(PSTR, STR );
 void permutation(PSTR, STR, unsigned int);

#endif
/*
 * szlTestFullPermutation.h
 */
 #ifndef SZL_TEST_FULLPERMUTATION_H
 #define SZL_TEST_FULLPERMUTATION_H
  
  void testFullPermutation(char* );
 
 #endif

/*
 * szlTestFullPermutation.c
 */
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "szlFactorial.h"
#include "szlWidthOfInteger.h"
#include "szlFullPermutation.h"
#include "szlTestFullPermutation.h"

void testFullPermutation(char* strPattern){
 int i;
 int nPattern;
 char **strDes;
 int nDes;
 int nPrintWidth;

 nPattern = strlen( strPattern );
 nDes = factorial( nPattern );

 //memory allocation
 strDes = (char **)malloc(sizeof(char*) * nDes);
 assert(strDes);

 for(i=0; i<nDes; i++){
  strDes[i] = (char *)malloc(sizeof(char) * (1+nPattern));
  assert(strDes[i]);
  strDes[i][0] = '\0';
 }

 //排列
 fullPermutation(strDes,strPattern);
 
 //print the result
 nPrintWidth = widthOfInteger(factorial(nPattern)); //szlWidthOfInteger.h, szlFactorial.h
 for(i=0; i<nDes; i++){
  fprintf(stdout, "%0*d %s\n",nPrintWidth, i+1, strDes[i]);
 }

 //free memory
 for(i=0; i<nDes; i++){
  if(strDes[i]){
   free(strDes[i]);
  }
 }
 
 if(strDes){
  free(strDes);
 }
}

/*
 * szlFullPermutation.c
 */
#include "szlFullPermutation.h"
#include "szlFactorial.h"
#include "szlWidthOfInteger.h"
#include "szlGetNumOfOneInInt.h"
#include "szlPower.h"

#include <string.h>

void fullPermutation(PSTR, STR );
void permutation(PSTR, STR, unsigned int);

void fullPermutation(PSTR pstrDes, STR strSrc){
  // 定义一个整数，相同索引位置上的值如果为1则表示在strSrc中对等位置的字符
  // 已经被挖出; 字符串长度应该不会超出32位;因此1个整数应该就可以标记了。
   unsigned int bMark;
   
   //初始时没有被处理，所以只为0
   bMark = 0;
   
   //bMark用于表示strSrc的处理深度：
   //bMark的二进制表示中，从左边起的第X位为1就表示字符数组strSrc的第X位已经
   //被处理过。
   //默认是从0开始索引的，假设。
   permutation(pstrDes,strSrc,bMark);
}


void permutation(PSTR pstrDes, STR strSrc, unsigned int bMark){
  int i,j,k; //循环变量
  int nSrc; //源字符串的长度
  PSTR pstrSec; //指向目标地址的相应位置，用于递归
  int nSec; //分割的间距，目标地址为分为nSrc段，每段的大小是nSec = (nSrc-1)!
  int nAddressed; //bMark中1的个数，也就是被使用的字符个数
  unsigned int nMark;
  unsigned int nSet;
  
  nSrc = strlen(strSrc); //输入的字符串包含的字符个数
  nAddressed = getNumOfOneInInt(bMark); //szlGetNumOfOneInInt.h
  nSec = factorial(nSrc - nAddressed - 1);//pstrSec用于指向待处理的目标地址
 
  //出口：传入只包含一个字符的字符串时结束
  //两种情形:
  //(1)输入恰好只有1个字符;
  //(2)输入超过1个字符，但是只剩下1个字符未被处理;
  if(2 > nSrc - nAddressed){ 
    //只包含一个字符了,nAddressed中第一个为0值的低位位置
    if(1 == nSrc){
      pstrDes[0][0] = strSrc[0];
	  pstrDes[0][1] = '\0';
	}
	else{ //nAddressed!=0, 找到唯一的0的索引，0的总数不超过nSrc.
	  int nIndexOfZero = 0;
	  nMark = bMark;
	  while(0 != nMark){ //nAddressed!=0, so initially 0!=temp
	    if(!(nMark&1)){
		  break;
		}
		else{
		  nMark = (nMark >> 1);
		  nIndexOfZero++;
		}
	  }
	  
	  //将该位置的字符取出赋值
	  pstrDes[0][nSrc-1] = strSrc[nIndexOfZero];
	  pstrDes[0][nSrc] = '\0'; 
	}
	//程序结束
	return;
  }

    // 循环：每次取出一个字符;
	// 填入目标地址的适当的位置中；
	nMark = bMark;
	for(i=0,k=0;i<nSrc;i++){ // default: nSrc < sizeof(unsigned int)
	  if(!(1&nMark)){
		nSet = 1;
		nSet = (nSet << i);//将第i位置为1,最左边为第0位
		pstrSec = pstrDes + k * nSec;//待处理的地址段
		for(j=0;j<nSec;j++){
		  pstrSec[j][nAddressed] = strSrc[i]; 
		}
		k++;
		
		//递归
		permutation(pstrSec,strSrc,(nSet|bMark));
	  }
	  nMark = (nMark >>1 );
	}
}

/*
 * main.c
 */
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "szlTestFullPermutation.h"
#include "szlTestSort.h"

int main(){
  char str[10];
  printf("str=\n");
  scanf("%s",str);
  testFullPermutation(str);
  
  return 0;
}


偶然从http://blog.csdn.net/hqw19881118/article/details/9103903看到一个递归版本的，非常简洁，写成了C语言版本。

/* permutation.c */
#include <assert.h>
#include <stdio.h>

void swap_char (char * p, char * q){   /* swap two char */
    if (p!=q){
        *p = *p ^ *q;
        *q = *p ^ *q;
        *p = *p ^ *q;
    }
}

void permutation(char* src, char* begin){ /* print permutation for the string src */
    assert (NULL!=src && NULL!=begin);

    if(*begin == '\0'){
        printf ("%s\n", src);
    }

    else{
        char * p;
        for(p = begin; *p != '\0'; p++){  /* loop for strlen(src) times */
            swap_char (p, begin);         /* swap *p and *begin */
            permutation(src, begin+1);    /* recursion from next character */
            swap_char (p, begin);         /* restore: swap *p and *begin once more */
        }
    }
}

int main(int argc, char* argv[]){
    char src[] = "abcd";
    permutation(src, src);
    return 0;
}


对上述的一个改进版本：升序打印。打印之前需要升序排列。

/* permutation.c : a sorted one (in ascendeng order) */
#include <assert.h>
#include <stdio.h>
#include <stdlib.h> /* qsort */

/* swap two char */
#define swap_char(r, q)\
    if (r!=q){         \
        *r = *r ^ *q;  \
        *q = *r ^ *q;  \
        *r = *r ^ *q;  \
    }                  

/* adjust sequence src so that the elements in it is in order:
 * p is the only positon that may breaks the order */
void sort_char (char * src, char * p); 

/* print permutation for the string src */
void permutation (char * src, char * begin);

/* for qsort */
int ch_cmp (const void * a, const void * b);


int main(int argc, char* argv[]){
    char src[] = "1324";

    qsort (src, 4, sizeof (char), ch_cmp);
    permutation(src, src);

    return 0;
}

/* print permutation for the string src */
void permutation (char * src, char * begin){ 
    assert (NULL != src && NULL != begin);

    if(* begin == '\0'){
        printf ("%s\n", src);
    }

    else{
        char * p;
        for(p = begin; *p != '\0'; p++){  /* loop for strlen(src) times */
            swap_char (p, begin);         /* swap *p and *begin */

            /* put *p into a position from the (begin+1) position so that the sequence 
             * from the (begin+1) position to then end position is in order */
            sort_char (begin + 1, p);   

            permutation(src, begin + 1);  /* recursion from next character */

            swap_char (p, begin);         /* restore: restore *p and *begin */
        }
    }
}

void sort_char (char * src, char * p){
    char * q, * r, * t = p;
    if (!('\0' == *src || '\0' == *(src + 1))){ /* there exists at least two characters */
        q = src;
        while ('\0' != *(q + 1)){
            q++;
        }

        r = p - 1;
        while (p > src){
            if (*p < *r){
                swap_char (p, r);
                t = r;
            }
            p--; 
            r--; 
        }

        r = p + 1;
        while (p < q){
            if (*p > *r){
                swap_char (p, r);
                t = r;
            }
            p++;
            r++;
        }
    }
    p = t;  /* restore : new *p is the input *p */
}

int ch_cmp (const void * a, const void * b){
    return *(char *)a - *(char *)b;
}


输出：

1234
1243
1324
1342
1423
1432
3124
3142
3214
3241
3412
3421
1234
1243
1324
1342
1423
1432
4123
4132
4213
4231
4312
4321


如果输入的字符串中有重复的字母，那么上述的算法的结果是有重复的。如何去掉重复的排列呢？

这里引用来自Huckbuteer1的博客

http://blog.csdn.net/Hackbuteer1/article/details/7462447#comments

的思想：

 

“由于全排列就是从第一个数字起每个数分别与它后面的数字交换。我们先尝试加个这样的判断——如果一个数与后面的数字相同那么这二个数就不交换了。如122，第一个数与后面交换得212、221。然后122中第二数就不用与第三个数交换了，但对212，它第二个数与第三个数是不相同的，交换之后得到221。与由122中第一个数与第三个数交换所得的221重复了。所以这个方法不行。”

 

“换种思维，对122，第一个数1与第二个数2交换得到212，然后考虑第一个数1与第三个数2交换，此时由于第三个数等于第二个数，所以第一个数不再与第三个数交换。再考虑212，它的第二个数与第三个数交换可以得到解决221。此时全排列生成完毕。
这样我们也得到了在全排列中去掉重复的规则——去重的全排列就是从第一个数字起每个数分别与它后面非重复出现的数字交换。”

 

修改为：

 

/* permutation.c : a sorted one (in ascendeng order) */
#include <assert.h>
#include <stdio.h>
#include <stdlib.h> /* qsort */

/* swap two char */
#define swap_char(r, q)\
    if (r!=q){         \
        *r = *r ^ *q;  \
        *q = *r ^ *q;  \
        *r = *r ^ *q;  \
    }                  

/* adjust sequence src so that the elements in it is in order:
 * p is the only positon that may breaks the order */
void sort_char (char * src, char * p); 

/* print permutation for the string src */
void permutation (char * src, char * begin);

/* for qsort */
int ch_cmp (const void * a, const void * b);

/* decide whether there exists a character equal to *end */
int is_swap (char * begin, char * end){
    char * p = begin;
    for (; p<end; p++){
        if (*p == *end){
            return 0;
        }
    }
    return 1;
}
int main(int argc, char* argv[]){
    char src[] = "1224";

    qsort (src, 4, sizeof (char), ch_cmp);
    permutation(src, src);

    return 0;
}

/* print permutation for the string src */
void permutation (char * src, char * begin){ 
    assert (NULL != src && NULL != begin);

    if(* begin == '\0'){
        printf ("%s\n", src);
    }

    else{
        char * p;
        for(p = begin; *p != '\0'; p++){  /* loop for strlen(src) times */
            if (is_swap (begin, p)){
                swap_char (p, begin);         /* swap *p and *begin */
                /* put *p into a position from the (begin+1) position so that the sequence 
                 * from the (begin+1) position to then end position is in order 
                 */
                /* sort_char (begin + 1, p);  *//* if call is_swap (), no longer sort */
                permutation(src, begin + 1);  /* recursion from next character */
                swap_char (p, begin);         /* restore: restore *p and *begin */
            }
        }
    }
}

void sort_char (char * src, char * p){
    char * q, * r, * t = p;
    if (!('\0' == *src || '\0' == *(src + 1))){ /* there exists at least two characters */
        q = src;
        while ('\0' != *(q + 1)){
            q++;
        }

        r = p - 1;
        while (p > src){
            if (*p < *r){
                swap_char (p, r);
                t = r;
            }
            p--; 
            r--; 
        }

        r = p + 1;
        while (p < q){
            if (*p > *r){
                swap_char (p, r);
                t = r;
            }
            p++;
            r++;
        }
    }
    p = t;  /* restore : new *p is the input *p */
}

int ch_cmp (const void * a, const void * b){
    return *(char *)a - *(char *)b;
}


1224
1242
1422
2124
2142
2214
2241
2421
2412
4221
4212
4122

问题又来了：如何在有重复字符串的排列中保证输出是升序呢？

BrightPi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
全排列（Full Permutation） || 暴力法 || 回溯法
陈三千的博客
02-24 531
== == == == == == == == == == == == == == == == == 全排列（Full Permutation）1_1 全排列（Full Permutation）1_2 n 皇后问题 - 暴力法 2_1 n 皇后问题 - 暴力法 2_2 n 皇后问题 - 回溯法 3_1 n 皇后问题 - 回溯法 3_2 == == == == == == == == == =...
permutation 系列
绝知此事要躬行
05-02 2197
关于permutation的讲解，请参见http://blog.csdn.net/xuqingict/article/details/24840183 下列题目的讲解均是基于上面的文章： 题1：  Next Permutation  Total Accepted: 8066 Total Submissions: 32493My Submissions
FullPermutation(全排列)
09-25
Full Permutation（全排列）的一个简单实现，仅仅对int类型的数组实现全排，可以根据自己的需要修改代码。欢迎交流。
算法:全排列(Full Permutation)-hdu1027
0xcc'Blog
05-01 261
全排列:从n个不同元素中任取m（m≤n）个元素，按照一定的顺序排列起来，叫做从n个不同元素中取出m个元素的一个排列。当m=n时所有的排列情况叫全排列。 c++算法实现: #include <iostream> using namespace std; const int MAXN = 1010; int n; void swap(int arr[],int p,int q) ...
permutation
09-19
如果一个长度为n序列包含1到n的每一个数字，那么我们说这个序列是一个长度为n的全排列。现给定一个长度为n-1由U和D构成的字符串，要求你构造一个字典序最小的全排列a，使其满足： 1.若第i个字符是U，则有a[i]<a[i+1]； 2.若第i个字符是D，则有a[i]>a[i+1]。 ★实验任务： 现在分别给你n以及长度为n-1的字符串，请你输出满足要求的最小字典序全排列。 ★数据输入： 输入数据第一行包含一个整数n(1≤n≤1000)，第二行包含长度为n-1由U和D构成的字符串。 ★结果输出： 输出由空格隔开的满足要求的全排列，如果找不到满足的全排列则输出-1。 输入示例 输出示例 7 2 1 3 5 4 7 6 DUUDUD
FullPermutation_java_算法_全排列_
10-02
全排列是计算机科学中一种常见的算法问题，主要应用于数据处理、搜索优化以及组合数学等领域。在Java编程中，实现全排列通常涉及到递归或回溯等技术。本篇将详细介绍两种常用的Java方法来解决全排列问题，并探讨相关...
蓝桥杯java历年真题及答案整理.doc
01-06
递归函数fullPermutation将源字符Vector和结果Vector作为参数，并在每次递归中移除当前字符，直到源字符Vector为空为止。 在main函数中，我们使用Scanner类来读取用户输入的字符个数，并将其转换为字符Vector。然后...
精心搜集整理：2014年前蓝桥杯Java竞赛历年试题及详尽答案
06-23
字符序列全排列挑战：此题考察全排列算法，需利用递归逻辑fullPermutation处理字符序列的每一种排列组合。算法精髓在于递归减少问题规模，通过交换元素位置实现排列变化，直至达到基本情况，即序列为空，此时输出...
C语言实现全排列算法模板的方法
08-25
void FullPermutation(int source[], int begin, int end) { int i; if (begin >= end) { for (i = 0; i ; i++) { printf("%d", source[i]); } printf("\n"); } else { for (i = begin; i ; i++) { if ...
Py||Full Permutation
Lhw_666的博客
10-25 153
题目描述 Write a program to list all the permutations that can be formed by N integers from 1 to N, and output them in lexicographic order. For example, given an integer N = 2, the permutations are: 1 2 2...
全排列就翻译为full permutation吧
newborn
04-10 1335
这里就学习下‘全排列’的翻译法：full permutation...
全排列的递归解法
D_R的博客
04-30 1551
#include <iostream> using namespace std; int total = 0; //交换函数 inline void swapArray(int &a, int &b) //设置成内联函数运行更快 { int temp; temp = a; a = b; b = temp; } //递归函数 void fullPermu
全排列（Full permutation）
最不正经的计算机专业学生
10-20 416
#include<cstdio> const int maxn=11; //P为当前排列，hashtable记录整数x是否已经在P中 int n,P[maxn],hasTablt[maxn]={false}; //当前处理排列的第index号位 void generateP(int index) { if(index==n+1)//递归便捷，已经处理完排列的1~n位 ...
经典递归问题--全排列FullPermutation--Java实现
RAVANLALA
03-29 357
package cn.LanQiaoBeiAlgorithm.Ravanla; /** * * @author Ravanlala *将一个字符串全排列 */ public class FullPermutation { public static void main(String[] args) { char[] arr = "ABCD".toCharArray(); f1(...
全排列（Full Permutation）（递归***）
jiangjiangjiang6的博客
02-18 293
从递归的角度考虑，如果把问题描述成“输出1~n这n个整数的全排列”，那么它就可以被分为若干个子问题：“输出以1开头的全排列”，“输出以2开头的全排列”。。。“输出以n开头的全排列”。于是不妨设定一个数组P，用来存放当前的排列；再设定一个散列数组hashTable，其中hashTable[x]当整数x已经在数组P中时为true。 现在按顺序往P的第1位到第n位中填入数字。不妨假设当前已经填好了P[...
详解全排列算法
数据与算法之美
03-05 915
简介给定 {1, 2, 3, , , n}，其全排列为 n! 个，这是最基础的高中组合数学知识。我们以 n=4 为例，其全部排列如下图（以字典序树形式来呈现）：我们很容易想到用递归来求出它的所有全排列。仔细观察上图，以 1 开头，下面跟着 {2, 3, 4} 的全排列；以 2 开头，下面跟着 {1, 3, 4} 的全排列；以 3 开头，下面跟着 {1, 2, 4} 的全排列；以 4 开头，下面跟着
基于豪猪优化算法CPO-VMD实现信号去噪目标函数为包络信息熵 包络熵 排列熵 样本熵最小附matlab代码.rar
最新发布
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
高分项目-基于SpringBoot框架实现的毕业生信息招聘平台（包含全套源码 + 数据库sql + 论文）.zip
07-19
【项目资源】：包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源、音视频、网站开发等各种技术项目的源码。包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。【项目质量】：所有源码都经过严格测试，可以直接运行。功能在确认正常工作后才上传。【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。【附加价值】：项目具有较高的学习借鉴价值，也可直接拿来修改复刻。对于有一定基础或热衷于研究的人来说，可以在这些基础代码上进行修改和扩展，实现其他功能。【沟通交流】：有任何使用上的问题，欢迎随时与博主沟通，博主会及时解答。鼓励下载和使用，并欢迎大家互相学习，共同进步。
蓝桥杯历年真题详解：字符排序算法与Java实现
否则，遍历`sourse`中的每个字符，将其添加到当前结果中，并递归调用`fullPermutation`方法处理剩余的字符，直到所有可能的排列都被探索完毕。 在`main`函数中，首先读取输入的字符数量`n`，然后创建一个包含'A'到'...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值