對於給定的集合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);
	}
}
 

字典序

全排列生成演算法的一個重要思路，就是將集合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);
	}
}

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