N个数的全排列

               我采用的方法是类似密码箱的转轮来得到所有的排列组合

比如求 1,2,3,4的所有排列组合

           ：采用递减式轮转来生成

N=4:
以1234为初始值

得到如下的所有4个组合，放入最终的容器中

 

     1 2 3 4
     2 3 4 1
     3 4 1 2
     4 1 2 3

N=3;
以上面的四个作为初始值，在第三位开始轮转

得到8个新的组合，追加放入最终的容器中

     2 3 1 4  //隐含的1 2 3 4组合在第一次已经得到，可以少做一次组合，下面的同理
     3 1 2 4
     3 4 2 1
     4 2 3 1
     4 1 3 2
     1 3 4 2
     1 2 4 3
     2 4 1 3

N=2;

以上面的到的12个组合作为种子，开始在第二位置处的轮转

得到12个新的组合，追加放入最终的容器中
     2 1 3 4
     3 2 4 1
     4 3 1 2
     1 4 2 3
     3 2 1 4
     1 3 2 4
     4 3 2 1
     2 4 3 1
     1 4 3 2
     3 1 4 2
     2 1 4 3
     4 2 1 3

最终得到了所有24个组合

#include<stdio.h>
#include<stdlib.h>
#define N 4
int arr[4] = { 1, 2 ,3,4};
int sz=1;      //全局变量，作为每次产生数据的存放地址
int countnum() //统计N个数共有多少的组合
{
	int ret = 1;
	for (int i = 1; i <=N; i++)
	{
		ret = ret*i;
	}
	return ret;
}
int rock(int**arry,int*str, int pos)
{
	int i = 0;
	int j = 0;
	int tmp = 0;
	for (i = 0; i < pos-1; i++)  //转动所有第pos项
	{
		tmp = str[0];  //保存第一个值其余的向前挪，
		for (int k = 0; k < N; k++) //复制上一行的值
		{
			arry[sz][k] = str[k];
		}
		for (j = 0; j < pos-1 ; j++) //开始一次轮换
		{
			arry[sz][j] = str[j + 1];
		}
		arry[sz][j] = tmp;
		str = arry[sz];  //更新str，开始下一次轮换
		sz++;
	}
	return pos;
}
int main()
{
	int i = 0;
	int j = 1;
	int len = 0;
	int *cup = NULL;
	int count = countnum();
	int*tmp = arr;
	int ret = N;
	int**str = malloc(count*sizeof(int*)); //存放所有组合的表
	for (i = 0; i < count; i++)
	{
		str[i] = malloc(N*sizeof(int));
	}
	for (i = 0; i < N; i++) //初始化第一项
	{
		str[0][i] = arr[i];
	}
	cup = str[0];
	rock(str, cup,N);
	int key = 1;
	for (i = N - 1; i >1; --i)
	{
		j = key * ret;
		key = j;
		for (; j > 0; j--) //j的值4，8，12，
		{
			cup = str[len];
			ret = rock(str, cup, i);
			len++;
		}
		len = 0; //len归零，从头开始执行j次，第Pos位轮转，
	}
	for (i = 0; i < count; i++)
	{
		for (int j = 0; j < N; j++)
		{
			printf(" %d", str[i][j]);
		}
		printf("\n");
	}
	printf("all the num is %d\n", i);
	return 0;
}