语言全排列函数_枚举全排列，一道华为面试题目

最新推荐文章于 2024-08-02 16:50:39 发布

weixin_39944542

最新推荐文章于 2024-08-02 16:50:39 发布

阅读量99

点赞数

文章标签：语言全排列函数

本文链接：https://blog.csdn.net/weixin_39944542/article/details/111701819

版权

今天参加了华为社招业务面试，面试的编码题目是让写一个字符串全排列的程序。我最后没写出来，当然也没通过面试。其实枚举全排列的算法我已经面对过两次了，这次没写出来真是不应该！当然，写出来也不一定能够通过面试，幸而我也没抱什么期望。

看来还是要多写写多总结，通过归纳总结和记录表达辅助对知识的吸收。一个只输入不输出的东西，就是一个怪物，比如黑洞。

下面这个是网上最常见到的打印全排列的算法的C语言实现

/* full_permutation.c 
 * Running it with Tinycc or GCC.
 */ 
#include <stdio.h>

#define swap(a, b) ({ typeof(a) tmp = a; a = b; b = tmp; })

void println(int *A, int npl)
{
    --npl;
    for (int i = 0; i < npl; ++i)
        printf("%dt", A[i]);
    printf("%dn", A[npl]);
}

void full_permutation(int *A, int begin, int end)
{
    if (begin >= end) {
        println(A, end + 1);
    }
    else {
        for (int i = begin; i <= end; ++i) {
            swap(A[begin], A[i]);
            full_permutation(A, begin + 1, end);
            swap(A[begin], A[i]);
        }
    }
}

int main()
{
    int A[] = {1, 2, 3, 4};
    full_permutation(A, 0, 3);
    return 0;
}

运行一下。砰砰砰，输出如下

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

这个full_permutation函数是一个递归函数，基本情况是要进行全排列的元素个数小于等于1，也就是begin >= end，这时我们把数组中的元素打印出来。对于复杂的情况，也就是begin < end，待进行全排列的元素的个数大于1，我们从begin位置开始，每次将一个元素交换到begin位置进行保存，而对begin之后的所有元素递归地进行全排列，全排列之后再将原来交换到begin位置的元素交换回它原来的位置，接着用相同的方法处理下一个元素，直到处理完begin之后的所有元素。

一个包括

个元素的数组的全排列有

种情况，所以

full_permutation的时间复杂度显然是

级别的。我好奇的是它会发生多少次函数调用，比如上面的

full_permutation(A, 0, 3);

这一句实际上发生了41次函数调用。

用

表示该函数对

个元素的数组进行全排列进行了多少次函数调用，可以得出这样一个关系式

可以通过迭代计算，它的通项公式是什么样的呢？我暂时还没解出来。

下面这是我用Scheme语言实现的版本，也是一个递归函数，生成给定的列表的全排列。

(define permute
  (lambda (ls)
    (or (and (null? ls) ls)
        (and (null? (cdr ls)) (list ls))
        (let help ((prev '())(curr (car ls))(rest (cdr ls))(res '()))
          (let ((res (append res (map (lambda (ls) (cons curr ls))
                                      (permute (append prev rest))))))
            (if (null? rest)
                res
                (help
                  (append prev (list curr))
                  (car rest)
                  (cdr rest)
                  res)))))))

我们来梳理一下它的运行过程。

对于长度为0的表，直接返回它本身；
对于长度为1的表，返回一个以它为唯一元素的表；
对于包含两个或两个以上元素的表，用一个循环（尾递归函数help）来进行处理。help的第1,2,3个参数prev, curr和rest分别表示已处理过的元素，当前元素和尚待处理的元素；第4个参数时全排列的结果。每一次循环，我们对除掉当前元素（(append prev rest)）的所有元素进行全排列，返回一个列表，然后用map函数进行映射，将当前元素curr插入该列表中的每个列表的头部，得到全排列的一个子集，并把这个子集合并到res中。然后继续循环，直到rest为空，返回res。

运行测试