问题来自《Linux C一站式编程》，是个挺有意思的题目。

2、定义一个数组，编程打印它的全排列。比如定义：

#define N 3 
int a[N] = { 1, 2, 3 };

则运行结果是：

$ ./a.out
1 2 3 
1 3 2 
2 1 3 
2 3 1 
3 2 1 
3 1 2

程序的主要思路是：

1. 把第1个数换到最前面来（本来就在最前面），准备打印1xx，再对后两个数2和3做全排列。
2. 把第2个数换到最前面来，准备打印2xx，再对后两个数1和3做全排列。
3. 把第3个数换到最前面来，准备打印3xx，再对后两个数1和2做全排列。

可见这是一个递归的过程，把对整个序列做全排列的问题归结为对它的子序列做全排列的问题，注意我没有描述Base Case怎么处理，你需要自己想。
你的程序要具有通用性，如果改变了N和数组a的定义（比如改成4个数的数组），其它代码不需要修改就可以做4个数的全排列（共24种排列）。

完成了上述要求之后再考虑第二个问题：如果再定义一个常量M表示从N个数中取几个数做排列（N==M时表示全排列），原来的程序应该怎么改？

最后再考虑第三个问题：如果要求从N个数中取M个数做组合而不是做排列，就不能用原来的递归过程了，想想组合的递归过程应该怎么描述，编程实现它。

不考虑数组元素相同的情况，我们可以按照题目提供的思路写出如下代码：

#include <stdio.h>
#define N 3

int a[N];

void perm(int); /*求数组的全排列 */
void print();
void swap(int, int);

int main(){
    int i;
    for(i = 0; i < N; ++i){
        a[i] = i + 1;
    }
    perm(0);
}

void perm(int offset){
    int i, temp;
    if(offset == N-1){  // BaseCase
        print();
        return;
    }else{
        for(i = offset;i < N; ++i){
            swap(i, offset);//交换前缀
            perm(offset + 1);//递归
            swap(i, offset);//将前缀换回来，继续做前一次排列
        }
    }
}

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

void swap(int i, int offset){
    int temp;
    temp = a[offset];
    a[offset] = a[i];
    a[i] = temp;
}

如果平常递归写的不多的话，这段代码还是很容易写错的（没错，我就是在说我自己）。
在Perm函数递归调用自己之后记得把元素位置交换回去，保证回溯时条件一致。

然后看第二个问题，这是更加一般的排列。仔细观察上面的代码，把特殊推导到一般，主要修改如下（用注释符标出）：

#include <stdio.h>
#define N 4
#define M 2   // 取出M个元素进行排列，默认M<=N

void print(){  
    int i;  
    for(i = 0; i < M; ++i)  // N->;m，打印a里前M个排列元素
        printf(" %d ",a[i]);  
    printf("n");  
}

void perm(int offset){  
    int i;  
    if(offset == M){  // N->M，排列到M个数时递归到达BaseCase
        print();  
        return;  
    }else{  
        for(i = offset;i < N; ++i){  
            swap(i, offset);
            perm(offset + 1);
            swap(i, offset); 
        }  
    }  
} 

再来看组合，同样用要求用递归解决，如果相关概念没有搞得很清楚，加上上面写的排列的代码，很容易写不出来（没错，说的还是我），然而代码其实很简单，不过递归确实更加复杂。

void comb(int n, int m)
{
    int i;
    if (m == 0) {
        print();
        return;
    } else {
        for (int i = n-1; i >= 0; --i)
        {
            b[m-1] = a[i];
            comb(i, m-1);
        }
    }
}

复杂之处在于，排列都是(n->n-1)这样的递归，然而组合这里是(n->i,m->m-1)这样非规律的递归调用，因为i是个变量。
但是组合的算法描述很简单，假设有一个两两元素互不相同的N长数组a，从数组尾端依次取M个数（b1,b2,···,bm）成为一个组合，并且满足条件：如果i>j,那么bi在a中的下标一定小于bj。

简单来说，就是从后往前取数组里的M个数，只有保持这样的偏序关系才能保证不会重复组合。