全排列算法（遞歸）

參考網址: https://www.pianshen.com/article/42791020055/

對於給定的集合A{a1,a2,...,an},其中的n個元素互不相同，如何輸出這n個元素的所有排列（全排列）。

遞歸算法

這里以A{a,b,c}為例，來說明全排列的生成方法，對於這個集合，其包含3個元素，所有的排列情況有3!=6種，對於每一種排列，其第一個元素有3種選擇a,b,c，對於第一個元素為a的排列，其第二個元素有2種選擇b,c；第一個元素為b的排列，第二個元素也有2種選擇a，c，……，依次類推，我們可以將集合的全排列與一棵多叉樹對應。如下圖所示

在此樹中，每一個從樹根到葉子節點的路徑，就對應了集合A的一個排列。通過遞歸算法，可以避免多叉樹的構建過程，直接生成集合A的全排列，代碼如下。

 

template <typename T>
inline void swap(T* array, unsigned int i, unsigned int j)
{
    T t = array[i];
    array[i] = array[j];
    array[j] = t;
}

/*
 * 遞歸輸出序列的全排列
 */
void FullArray(char* array, size_t array_size, unsigned int index)
{
    if(index >= array_size)
    {
        for(unsigned int i = 0; i < array_size; ++i)
        {
            cout << array[i] << ' ';
        }

        cout << '\n';

        return;
    }

    for(unsigned int i = index; i < array_size; ++i)
    {
        swap(array, i, index);

        FullArray1(array, array_size, index + 1);

        swap(array, i, index);
    }
}

該算法使用原始的集合數組array作為參數代碼的28～32行，將i位置的元素，與index位置的元素交換的目的是使得array[index + 1]到array[n]的所有元素，對應當前節點的后繼結點，遞歸調用全排列生成函數。調用結束之后還需要回溯將交換位置的元素還原，以供其他下降路徑使用。

字典序

全排列生成算法的一個重要思路，就是將集合A中的元素的排列，與某種順序建立一一映射的關系，按照這種順序，將集合的所有排列全部輸出。這種順序需要保證，既可以輸出全部的排列，又不能重復輸出某種排列，或者循環輸出一部分排列。字典序就是用此種思想輸出全排列的一種方式。這里以A{1,2,3,4}來說明用字典序輸出全排列的方法。

首先，對於集合A的某種排列所形成的序列，字典序是比較序列大小的一種方式。以A{1,2,3,4}為例，其所形成的排列1234<1243，比較的方法是從前到后依次比較兩個序列的對應元素，如果當前位置對應元素相同，則繼續比較下一個位置，直到第一個元素不同的位置為止，元素值大的元素在字典序中就大於元素值小的元素。上面的a1[1...4]=1234和a2[1...4]=1243，對於i=1,i=2，兩序列的對應元素相等，但是當i=2時，有a1[2]=3<a2[2]=4，所以1234<1243。

使用字典序輸出全排列的思路是，首先輸出字典序最小的排列，然后輸出字典序次小的排列，……，最后輸出字典序最大的排列。這里就涉及到一個問題，對於一個已知排列，如何求出其字典序中的下一個排列。這里給出算法。

• 對於排列a[1...n]，找到所有滿足a[k]<a[k+1](0<k<n-1)的k的最大值，如果這樣的k不存在，則說明當前排列已經是a的所有排列中字典序最大者，所有排列輸出完畢。
• 在a[k+1...n]中，尋找滿足這樣條件的元素l，使得在所有a[l]>a[k]的元素中，a[l]取得最小值。也就是說a[l]>a[k]，但是小於所有其他大於a[k]的元素。
• 交換a[l]與a[k].
• 對於a[k+1...n]，反轉該區間內元素的順序。也就是說a[k+1]與a[n]交換，a[k+2]與a[n-1]交換，……，這樣就得到了a[1...n]在字典序中的下一個排列。

這里我們以排列a[1...8]=13876542為例，來解釋一下上述算法。首先我們發現，1(38)76542，括號位置是第一處滿足a[k]<a[k+1]的位置，此時k=2。所以我們在a[3...8]的區間內尋找比a[2]=3大的最小元素，找到a[7]=4滿足條件，交換a[2]和a[7]得到新排列14876532，對於此排列的3～8區間，反轉該區間的元素，將a[3]-a[8]，a[4]-a[7]，a[5]-a[6]分別交換，就得到了13876542字典序的下一個元素14235678。下面是該算法的實現代碼

 

/*
 * 將數組中的元素翻轉
 */
inline void Reverse(unsigned int* array, size_t array_size)
{
    for(unsigned i = 0; 2 * i < array_size - 1; ++i)
    {
        unsigned int t = array[i];
        array[i] = array[array_size - 1 - i];
        array[array_size - 1 - i] = t;
    }
}

inline int LexiNext(unsigned int* lexinum, size_t array_size)
{
    unsigned int i, j, k, t;

    i = array_size - 2;

    while(i != UINT_MAX && lexinum[i] > lexinum[i + 1])
    {
        --i;
    }

    //達到字典序最大值
    if(i == UINT_MAX)
    {
        return 1;
    }

    for(j = array_size - 1, k = UINT_MAX; j > i; --j)
    {
        if(lexinum[j] > lexinum[i])
        {
            if(k == UINT_MAX)
            {
                k = j;
            }
            else
            {
                if(lexinum[j] < lexinum[k])
                {
                    k = j;
                }
            }
        }
    }

    t = lexinum[i];
    lexinum[i] = lexinum[k];
    lexinum[k] = t;

    Reverse(lexinum + i + 1, array_size - i - 1);
    return 0;
}

/*
 * 根據字典序輸出排列
 */
inline void ArrayPrint(const char* array, size_t array_size, const unsigned int* lexinum)
{
    for(unsigned int i = 0; i < array_size; ++i)
    {
        cout << array[lexinum[i]] << ' ';
    }

    cout << '\n';
}

/*
 * 基於逆序數的全排列輸出
 */
void FullArray(char* array, size_t array_size)
{
    unsigned int lexinumber[array_size];

    for(unsigned int i = 0; i < array_size; ++i)
    {
        lexinumber[i] = i;
    }

    ArrayPrint(array, array_size, lexinumber);

    while(!LexiNext(lexinumber, array_size))
    {
        ArrayPrint(array, array_size, lexinumber);
    }
}

使用字典序輸出集合的全排列需要注意，因為字典序涉及兩個排列之間的比較，對於元素集合不方便比較的情況，可以將它們在數組中的索引作為元素，按照字典序生成索引的全排列，然后按照索引輸出對應集合元素的排列，示例代碼使用的就是此方法。對於集合A{a,b,c,d}，可以對其索引1234進行全排列生成。這么做還有一個好處，就是對於字典序全排列生成算法，需要從字典序最小的排列開始才能夠生成集合的所有排列，如果原始集合A中的元素不是有序的情況，字典序法將無法得到所有的排列結果，需要對原集合排序之后再執行生成算法，生成索引的全排列，避免了對原始集合的排序操作。

字典序算法還有一個優點，就是不受重復元素的影響。例如1224，交換中間的兩個2，實際上得到的還是同一個排列，而字典序則是嚴格按照排列元素的大小關系來生成的。對於包含重復元素的輸入集合，需要先將相同的元素放在一起，以集合A{a,d,b,c,d,b}為例，如果直接對其索引123456進行全排列，將不會得到想要的結果，這里將重復的元素放到相鄰的位置，不同元素之間不一定有序，得到排列A'{a,d,d,b,b,c}，然后將不同的元素，對應不同的索引值，生成索引排列122334，再執行全排列算法，即可得到最終結果。

本文鏈接：https://blog.csdn.net/saber_wtq/article/details/79344877