精华内容
下载资源
问答
  • 递归全排列

    2019-11-27 23:28:00
    问题:输出一个序列的全排列,用递归解决。 思路: 定义一个全排列生成函数 当序列长度为1时,它的全排列就是这个元素,可以直接输出; 当序列长度>1时,它的全排列就是,每个元素跟着其他元素的全排列; 当序列...

    问题:输出一个序列的全排列,用递归解决。


    思路:
    定义一个全排列生成函数
    当序列长度=1时,它的全排列就是这个元素,可以直接输出;
    当序列长度>1时,它的全排列就是,每个元素跟着其他元素的全排列;
    当序列长度>1时,对于每个元素,再以去掉这个元素后的序列为参数,递归调用全排列生成函数,这样,每次递归调用序列长度都会减1,直到序列长度为1,可以直接输出。


    c++实现:

    #include <iostream>
    using namespace std;
    
    template<class T>
    void swapMy(T &a, T &b)
    {
    	T temp = a;
    	a = b;
    	b = temp;
    }
    
    template<class T>
    void perm(T list[], int k,int len)
    {
    	if (k == len-1)
    	{
    		for (int i = 0; i < len; i++)
    			cout << list[i];
    		cout << endl;
    	}
    	else
    	{
    		for (int i = k; i < len; i++)
    		{
    			swapMy(list[k], list[i]);
    			perm(list, k + 1, len);
    			swapMy(list[k], list[i]);
    		}
    	}
    }
    
    int main()
    {
    	char s[] = "abc";
    	perm(s, 0, 3);
    	return 0;
    }
    

    测试结果:
    在这里插入图片描述

    展开全文
  • 主要为大家详细介绍了python递归全排列实现方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 本文实例为大家分享了python递归全排列的实现方法,供大家参考,具体内容如下排列:从n个元素中任取m个元素,并按照一定的顺序进行排列,称为排列;全排列:当n==m时,称为全排列;比如:集合{ 1,2,3}的全排列为:{ ...

    本文实例为大家分享了python递归全排列的实现方法,供大家参考,具体内容如下

    排列:从n个元素中任取m个元素,并按照一定的顺序进行排列,称为排列;

    全排列:当n==m时,称为全排列;

    比如:集合{ 1,2,3}的全排列为:

    { 1 2 3}

    { 1 3 2 }

    { 2 1 3 }

    { 2 3 1 }

    { 3 2 1 }

    { 3 1 2 }

    递归思想:

    取出数组中第一个元素放到最后,即a[1]与a[n]交换,然后递归求a[n-1]的全排列

    1)如果数组只有一个元素n=1,a={1} 则全排列就是{1}

    2)如果数组有两个元素n=2,a={1,2} 则全排列是:

    {2,1}--a[1]与a[2]交换。交换后求a[2-1]={2}的全排列,归结到1)

    {1,2}--a[2]与a[2]交换。交换后求a[2-1]={1}的全排列,归结到1)

    3)如果数组有三个元素n=3,a={1,2,3} 则全排列是

    {{2,3},1}--a[1]与a[3]交换。后求a[3-1]={2,3}的全排列,归结到2)

    {{1,3},2)--a[2]与a[3]交换。后求a[3-1]={1,3}的全排列,归结到2)

    {{1,2},3)--a[3]与a[3]交换。后求a[3-1]={1,2}的全排列,归结到2)

    ...

    依此类推。

    利用python实现全排列的具体代码perm.py如下:

    COUNT=0

    def perm(n,begin,end):

    global COUNT

    if begin>=end:

    print n

    COUNT +=1

    else:

    i=begin

    for num in range(begin,end):

    n[num],n[i]=n[i],n[num]

    perm(n,begin+1,end)

    n[num],n[i]=n[i],n[num]

    n=[1,2,3,4]

    perm(n,0,len(n))

    print COUNT

    最后输出的结果如下:

    ======================== RESTART: D:/Python27/perm.py ========================

    [1, 2, 3, 4]

    [1, 2, 4, 3]

    [1, 3, 2, 4]

    [1, 3, 4, 2]

    [1, 4, 3, 2]

    [1, 4, 2, 3]

    [2, 1, 3, 4]

    [2, 1, 4, 3]

    [2, 3, 1, 4]

    [2, 3, 4, 1]

    [2, 4, 3, 1]

    [2, 4, 1, 3]

    [3, 2, 1, 4]

    [3, 2, 4, 1]

    [3, 1, 2, 4]

    [3, 1, 4, 2]

    [3, 4, 1, 2]

    [3, 4, 2, 1]

    [4, 2, 3, 1]

    [4, 2, 1, 3]

    [4, 3, 2, 1]

    [4, 3, 1, 2]

    [4, 1, 3, 2]

    [4, 1, 2, 3]

    24

    >>>

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

    时间: 2018-08-16

    展开全文
  • 递归 全排列

    2017-08-18 15:20:20
  • 下面小编就为大家带来一篇python非递归全排列实现方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Java递归全排列

    2021-01-19 15:25:34
    Java递归全排列 目录 1, 全排列实现思路 排列组合概念 理解 2,全排列的重点 3,全排列java实现 Java: 结果: 总结: 1, 全排列实现思路 排列组合概念 排列,就是指从给定n个数的元素中取出指定m个...

     Java递归全排列

    目录

     

    1, 全排列实现思路

    排列组合概念

    理解

    2,全排列的重点

     3,全排列java实现

     Java:

    结果:

    总结:


    1, 全排列实现思路

    排列组合概念

    排列,就是指从给定n个数的元素中取出指定m个数的元素,进行排序

     https://images2017.cnblogs.com/blog/124398/201712/124398-20171216012242168-1277603008.png  

    组合,则是指从给定n个数的元素中仅仅取出指定m个数的元素,不考虑排序

    https://images2017.cnblogs.com/blog/124398/201712/124398-20171216012301574-1912634832.png

     

    全排列就是从“第一个字符”起,“每个字符”分别与它“后面的字符”交换,复杂度为O(n!)

     

    理解

    1. A依次和BCD交换
    2. 交换一次后不急(如先进行A跟B交换后有,不急着交换AC、AD,先变成BACD),target后移,再依次交换
    3. 直到target=最后一个数时,停止,输出
    4. 返回上一步(用递归)接着做,此时要注意,把换了的数再还回来

     

    2,全排列的重点

      全排列难的是怎么理解这个过程;确实也不怎么好理解。

     

     // 2 先进行交换
    
    swapIndex(array, index, i);
    
    // 3. 递归
    
    fullPermutation(array, index + 1);
    
    // 5. 返回上层,交换换回来
    
    swapIndex(array, index, i);
    
     


     3,全排列java实现

     Java:

    public class FullPermutationT {
    
        public static void main(String[] args) {
    //        Integer[] array =  {1,2,3,4,5};
    //        // 1.从0开始
    //        fullPermutation(array, 0);
    
            String[] strArr =  {"A","B","C", "D"};
            // 1.从0开始
            fullPermutation(strArr, 0);
    
        }
    
        public static <T> void fullPermutation(T[] array, int index) {
    
            if (index == array.length) {
                // 4.停止,进行输出
                System.out.println(Arrays.toString(array));
                return;
            }
    
            for (int i = index; i < array.length; i++) {
                // 2 先进行交换
                swapIndex(array, index, i);
                // 3. 递进 target 往后移动
                fullPermutation(array, index + 1);
                // 5. 返回上层,交换换回来
                swapIndex(array, index, i);
            }
        }
    
        /**
         * 交换arr中i和j的值
         * @param array
         * @param i
         * @param j
         */
    
        public static <T> void swapIndex(T[] array, int i, int j) {
            T temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    
    }

     

    结果:

    [A, B, C, D]
    
    [A, B, D, C]
    
    [A, C, B, D]
    
    [A, C, D, B]
    
    [A, D, C, B]
    
    [A, D, B, C]
    
    [B, A, C, D]
    
    [B, A, D, C]
    
    [B, C, A, D]
    
    [B, C, D, A]
    
    [B, D, C, A]
    
    [B, D, A, C]
    
    [C, B, A, D]
    
    [C, B, D, A]
    
    [C, A, B, D]
    
    [C, A, D, B]
    
    [C, D, A, B]
    
    [C, D, B, A]
    
    [D, B, C, A]
    
    [D, B, A, C]
    
    [D, C, B, A]
    
    [D, C, A, B]
    
    [D, A, C, B]
    
    [D, A, B, C]

     

    总结:

        理解全排列递归的过程,并不直观。实现相对来说是比较简单的,主要是理解了。后面有机会把理解写得清楚一些。

     

     

     

    展开全文
  • C++递归全排列

    2021-03-17 21:13:42
    递归全排列: #include<iostream> using namespace std; template<typename T> void Rank(T* arr, int n, int k=0)//k:考虑到第k个 n:数组元素个数 { if (k == n)//到了最后一个数 { for (int i = 0...
  • 递归全排列、DFS

    2019-09-17 19:33:09
    递归全排列 题目描述 排列与组合是常用的数学方法。 先给一个正整数 ( 1 < = n < = 10 ) 例如n=3,所有组合,并且按字典序输出: 1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1 输入 输入一个整数n( 1<=n<=10) ...
  • 算法:递归全排列

    2020-03-25 00:53:51
    算法:递归全排列 排列组合是我高中就很头疼的东西,今天在牛客网刷到了全排列的题,硬着脑袋搞懂了。 全排列 比如给定一个数组[a,b,c],需要将其所有的排列方式输出:abc,acb,bac,bca,cab,cba共6种。 分析 没有重复...
  • 递归全排列

    千次阅读 2016-08-13 13:09:37
    递归全排列无非就是根据一个排列找到下一个; 以1 2 3 4 为例子; 1:先把给定的字符串排序(于小到大); 2:从后到前找到第一个相邻的递增对;例如:1 2 4 3 找到2 4 递增 于是得到4的下标2;如果没有找到,...
  • 递归全排列算法

    2014-10-12 09:06:38
    这是一个递归完成全排列的算法,使用的是C++进行编程,希望能帮到你~
  • 结合数组操作,写了个非递归全排列生成。原理是插入法,也就是在一个有n个元素的已有排列中,后加入的元素,依次在前,中,后的每一个位置插入,生成n+1个新的全排列。因为Python切割数组或者字符串,以及合并比较...
  • 设(ri)perm(X)表示每一个全排列前加上前缀ri得到的排列.当n=1时,perm(R)=(r) 其中r是唯一的元素,这个就是出口条件.当n>1时,perm(R)由(r1)perm(R1),(r2)perm(R2),...(rn)perm(Rn)构成.k表示前缀的位置,m是要排列的...
  • 递归全排列问题 固定位置放元素、固定元素找位置
  • [递归 全排列&N皇后]

    2021-01-27 16:14:51
    [递归 全排列&N皇后] Description 递归求出全排列,如输出1到5的全排列 Code【全排列】 #include <cstdio> const int maxn=11; int n,P[maxn]={0}; //P存放已经排进来的数,n即为要求输出1~n的...
  • python algorithm全排列(Permutation)排列(英语:Permutation)是将相异物件或符号根据确定的顺序重排。每个顺序都称作一个排列。例如,从一到六的数字有720种排列,对应于由这些数字组成的所有不重复亦不阙漏的...
  • 递归全排列实现

    2016-04-07 18:29:21
    递归全排列实现 #include #include #include #include #include #include #include #include using namespace std; const int MAX_SIZE = 1000; /* 寻找下一个排列 假设 某个序列为 d1 d2 d3 ... dn 那么在dn前找...
  • 实例四十五:递归全排列 **问题描述:**使用递归方法对数组元素进行全排列输出。 算法思路: 设X={x1,x2,…,xn}是要进行全排列的 n 个元素,集合 X 的全排列记为 Perm(X)。当 n=1 时,X 的元素是唯一的,那么...
  • 今天刚刚接触到一个关于数组递归全排列的问题,看了别人写的相关介绍,自己根据理解也来献丑一下。我这里写的数组全排列问题主要用的就是递归的方法来实现这个数组的全排列问题。array[4]={1,2,3,4},对这个数组进行...
  • 递归全排列(C#)

    2016-01-20 19:07:00
    递归全排列(C#): static int[] xx=new int[4]; static void Main(string[] args) { printP(4, xx, 0); } static void printP(int n,int [] A,int cur) { ...
  • 递归全排列 python实现

    千次阅读 2018-04-18 20:25:15
    全排列递归方法 全排列: 1、列表只有一个元素[a],它的全排列只有a。 2、列表有两个元素[a, b],它的全排列为[a, b], [b, a]: { 将第一个元素a固定,对b进行全排列得到[a, b]。 将第一个元素与第二个元素...
  • python递归 全排列

    2020-09-19 19:30:36
    = 1: # 如果当前lst长度为1,停止递归,返回 return [lst] result = [] for i in range(len(lst)): s = lst[:i]+lst[i+1:] # 每一次拿出一个元素 p = perm(s) # 得到剩下元素的全排列 for x in p: result....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,000
精华内容 8,000
关键字:

递归全排列