全排列，组合的生成算法(python版)

数学前提

对于一个n元集合，它的全排列数量是，可以这样推导：根据乘法原理，第1个位置有n种选择，第2个位置有(n-1)种选择.....如此，则全排列的数量是

从n元集合中选择r个元素的数量是，可以这样推导：第1个元素有n种选择，第2个元素有(n-1)种选择....第r个元素有(n-r+1)种选择，但是组合是无序的，还要除以选出来的元素本身的排列，故总数量为：

组合的生成算法：最大下标法

从n元集中给出一个r元组合生成它的下一个组合算法是：

1.求出满足的最大下标 i，即

2.令

3.从第 i+1 位开始，令

这个算法，当第一个输入的组合是时，可以生成出所有的组合，代码实现如下：

def combination(datas:list,r:int):
    length = len(datas)
    ans = []
    selectSequence = [i+1 for i in range(r)]
    while True:
        ans.append([datas[i-1] for i in selectSequence])
        maximum = -1
        for i in range(r):
            if selectSequence[i] < length-r+(i+1) and (i+1)>maximum:
                maximum = i+1
        if maximum == -1:
            break
        selectSequence[maximum-1] += 1
        for i in range(maximum,r):
            selectSequence[i] = selectSequence[i-1]+1
    return ans

测试结果如下：

datas = ["a","r",456,[1,2]]
ans = combination(datas,2)
print(ans)

>>>
[['a', 'r'], ['a', 456], ['a', [1, 2]], ['r', 456], ['r', [1, 2]], [456, [1, 2]]]

因为生成全部的组合总是要遍历到每一种组合的情况，所以这个算法的时间复杂度时 

全排列的生成算法

字典序法

字典序法就是将元素都按照字典序进行排列，依次生成全排列，举个例子，集合的字典序排列如下图（这里只对1展开了）

对于一个给定的排列，生成它的下一个排列的算法是：

1.求满足关系式的 j 的最大值，记为 i 即

2.求满足关系式的 k 的最大值，记为 j 即

3.互换和

4.将互换之后的序列的第 i-1 位之后的元素逆序，得到下一个排列

代码实现如下：

def dictArrange(n):
    elements = list(range(1,n+1))
    while True:

        # do something here
        print(elements)

        i,j = -1,-1
        for index in range(n-1):
            if elements[index] < elements[index+1] and index > i:
                i = index
        if i == -1:
            break
        for index in range(n):
            if elements[index] > elements[i] and index > j:
                j = index
        elements[i],elements[j] = elements[j],elements[i]
        left, right = i + 1, n - 1
        while left < right:
            elements[left], elements[right] = elements[right], elements[left]
            left += 1
            right -= 1

测试如下

dictArrange(3)

>>>[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]

这个算法的时间复杂度是，而且是就地修改序列，不额外占用空间

换位法

换位法，即算法。换位法将存储一个状态数组，这个状态有两种，-1 和 1 ，分别表示当前元素指向前一个元素或者后一个元素。每个元素的初始状态都将被设置为 -1 。一个元素是活动的，当且仅当该元素状态指向的元素小于该元素。当所有的元素都不处于活动状态时，生成排列完毕。

举个例子，如下图

给定一个排列，生成下一个排列的方法是：

1.求出所有处于活跃状态的元素中最大的元素，记为 m 

2.将 m 和它指向的元素互换位置

3.将序列中所有大于 m 的元素指向的箭头转换方向

代码实现如下：

def arrange(n:int):
    elements = list(range(1,n+1))
    status = [-1 for _ in range(n)]
    while True:

        # do something here
        print(elements)

        maxIndex,maximum = -1,-1
        for index in range(n):
            temp_index = index + status[index]
            if 0 <= temp_index < n and elements[index] > elements[temp_index] and elements[index] > maximum:
                maxIndex = index
                maximum = elements[index]
        if maxIndex == -1:
            break
        temp_index = maxIndex + status[maxIndex]
        elements[temp_index],elements[maxIndex] = elements[maxIndex],elements[temp_index]
        status[temp_index],status[maxIndex] = status[maxIndex],status[temp_index]
        for index in range(n):
            if elements[index] > maximum:
                status[index] *= -1

 测试如下：

arrange(3)

>>>[1, 2, 3]
[1, 3, 2]
[3, 1, 2]
[3, 2, 1]
[2, 3, 1]
[2, 1, 3]

这个算法的时间复杂度是。根据输出结果注意到，这个算法其实是让最大的元素在序列中从后向前，再从前向后，也是就地修改序列，只额外占用存储状态数组的空间

回顾往期：

基本排序方法的python实现

普利姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法C语言实现

栈，队列，二叉树的实现和基本方法