C语言全排列算法（最详细讲解）

Insomniacs_01

于 2024-05-10 21:41:12 发布

阅读量1.2k

点赞数 30

文章标签：算法 c语言数据结构

本文链接：https://blog.csdn.net/Insomniacs_01/article/details/138679095

版权

今天做数据结构题，发现了一道很有趣的题目，该题目具体如下：

【问题描述】输入整数N( 1 <= N <= 10 )，生成从1~N所有整数的全排列。
【输入形式】输入整数N。
【输出形式】输出有N!行，每行都是从1~N所有整数的一个全排列，各整数之间以空格分隔。各行上的全排列不重复。输出各行遵循“小数优先”原则, 在各全排列中，较小的数尽量靠前输出。如果将每行上的输出看成一个数字，则所有输出构成升序数列。具体格式见输出样例。
【样例输入1】1
【样例输出1】1
【样例说明1】输入整数N=1，其全排列只有一种。
【样例输入2】3
【样例输出2】
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
【样例说明2】输入整数N=3，要求整数1、2、3的所有全排列, 共有N!=6行。且先输出1开头的所有排列数，再输出2开头的所有排列数，最后输出3开头的所有排列数。在以1开头的所有全排列中同样遵循此原则。
【样例输入3】10
【样例输出3】
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 10 9
1 2 3 4 5 6 7 9 8 10
1 2 3 4 5 6 7 9 10 8
1 2 3 4 5 6 7 10 8 9
1 2 3 4 5 6 7 10 9 8
1 2 3 4 5 6 8 7 9 10
1 2 3 4 5 6 8 7 10 9
1 2 3 4 5 6 8 9 7 10
1 2 3 4 5 6 8 9 10 7
……………………
【样例说明3】输入整数N=10，要求整数1、2、3、……、10的所有全排列。上例显示了输出的前10行。
【运行时限】要求每次运行时间限制在20秒之内。超出该时间则认为程序错误。提示：当N增大时，运行时间将急剧增加。在编程时要注意尽量优化算法，提高运行效率。
【评分标准】该题要求输出若干行整数。

然后答案代码如下：

#include <stdio.h>
#include <stdlib.h>

void generatePermutations(int arr[], int N);
void printPermutation(int arr[], int N);
int compare(const void *a, const void *b);
int next_permutation(int arr[], int N);

int main() {
    int N;
    scanf("%d", &N);

    int arr[N], i;
    for (i = 0; i < N; i++) {
        arr[i] = i + 1;
    }

    generatePermutations(arr, N);

    return 0;
}

void generatePermutations(int arr[], int N) {
    int i;
    qsort(arr, N, sizeof(int), compare); // 对数组进行排序，确保从小到大排列

    do {
        printPermutation(arr, N); // 输出排列
    } while (next_permutation(arr, N)); // 获取下一个排列
}

void printPermutation(int arr[], int N) {
    int i;
    for (i = 0; i < N; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int compare(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

int next_permutation(int arr[], int N) {
    int i = N - 2;
    while (i >= 0 && arr[i] >= arr[i + 1]) {
        i--;
    }
    if (i < 0) {
        return 0; // 已经是最后一个排列，无法获取下一个排列
    }
    int j = N - 1;
    while (arr[j] <= arr[i]) {
        j--;
    }
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
    int left = i + 1, right = N - 1;
    while (left < right) {
        temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        left++;
        right--;
    }
    return 1;
}

刚开始看到这个代码，我实在是一脸的疑惑------这是递归了个啥啊！等到上网搜索了好久，我才搞明白这个这个典型问题--全排列问题。

关于解决这个问题的方法，其实无外乎还是运用了回溯算法。

以下是我提炼出来的相关代码：

#include <stdio.h>
int mark[11],a[11];
void dfs(int step,int n);
int main()
{
	int n=0;
	scanf("%d",&n);
	dfs(1,n);
	return 0;
}
 
void dfs(int step,int n)
{
	if(step>n)
	{
		int i=0;
		for(i=1;i<=n;i++)
		{
			printf("%d",a[i]);
			if(i!=n)
			{
				printf(" ");
			}
			else 
				printf("\n");
		}
	}
	else
	{
		int i=0; 
		for(int i=1;i<=n;i++)
		{
			if(mark[i]==0)
			{
				mark[i]=1;
				a[step]=i;
				dfs(step+1,n);
				mark[i]=0;
				
			}	
		}
		
	}
}

下面我以n=3为例画了一张图标，可能可以看的更清楚些。

很典型的多叉树对不对。

现在，对dfs函数进行一下详解：

首先在主函数中传入

	dfs(1,n);

表示step=1，即执行第一步（数组中一共有step-1个元素），而上限为n,表示一共执行n步（即数组一共有n个元素）。

当进入dfs函数后

if(step>n)
	{
		int i=0;
		for(i=1;i<=n;i++)
		{
			printf("%d",a[i]);
			if(i!=n)
			{
				printf(" ");
			}
			else 
				printf("\n");
		}
	}

先判断step是否比n大，当step>n时，表示数组中此时的元素个数>=n（当然不可能>n，因为在等于n时就停止了）。此时打印数组。

当step<=n,现在数组还没有填满

else
	{
		int i=0; 
		for(i=1;i<=n;i++)
		{
			if(mark[i]==0)
			{
				mark[i]=1;
				a[step]=i;
				dfs(step+1,n);
				mark[i]=0;
				
			}	
		}
		
	}

还记得我们在我们定义的全局变量a[11],mark[11]吗？