。。。。
。。。。

[ 本帖最后由 BlueGuy 于 2011-3-10 20:39 编辑 ]

运行时程序结果只有这些吗
1 2 3 4
1 2 3 5
1 2 4 5
1 3 4 5
2 3 4 5
输出的结果不对啊，程序有问题，
PS：我不会用递归排序，很麻烦

c(5, 4) = 5 !!!!!!!

哦，理解错误，想了排列去，如果要分析代码花不了时间。不过对自己有帮助。
就像
代码分析：

recursion(1)
{
      while(1<=5)
   {
    combination[1] = 1;
       recursion(2)
    }
}

recursion(2)
{
    while(2<=5)
    {
      combination[2] = 2;
      recursion(3)
    }
}

recursion(3)
{
    while(3<=5)
    {
      combination[3] = 3;
      recursion(4)
    }
}

recursion(4)
{
    while(4<=5)
    {
      combination[4] = 4;
      if(4==4)
      {
        printf();  // X,1 2 3 4
      }
    }
}继续补充ing

引用定义。

//能够帮助到大家， 就算失业我也开心
楼主真是高尚啊，赞一个

代码分析：

recursion(1)
{
      while(1<=5)
   {
    combination[1] = 1;
       recursion(2)
    }
}

recursion(2)   //recursion(1)要压栈,记录 i=1,还没有执行
完,因为for()还没有结束循环
{
    while(2<=5)
    {
      combination[2] = 2;
      recursion(3)
    }
}

recursion(3)   //recursion(2)要压栈,记录 i=2,还没有执行
完,因为for()还没有结束循环
{
    while(3<=5)
    {
      combination[3] = 3;
      recursion(4)
    }
}

recursion(4)     //recursion(3)要压栈,记录 i=3,还没有执
行完,因为for()还没有结束循环
{
    while(4<=5)
    {
      combination[4] = 4;
      if(4==4)
      {
        printf();  //    开始打印 1 2 3 4
      }
    }
}

recursion(4)  // 继续执行循环，直到循环结束
{
    while(5<=5)
    {
      combination[4] = 5; //0,1 2 3 5
      if(4==4)
      {
        printf();  //  开始打印  1 2 3 5
      }
    }
}

recursion(4) //循环结束  

recursion(3)   //之前压栈，现在退栈,结束上次循环,i现在为
4,原因是循环还没有结束
{
    while(4<=5)  //i之前是3
    {
      combination[3] = 4; //0,1 2 4 5
      recursion(4)
    }
}

recursion(4)   //recursion(3)要继续压栈,记录 i=4,还没有
执行完,因为for()还没有结束循环
{
    while(4<=5)
    {
      combination[4] = 4;  // 0, 1 2 4 4
      if(4==4)
      {
        if(k!=4)
      }
    }
}

recursion(4)  // 继续执行循环，直到循环结束,且打印数据
{
    while(5<=5)
    {
      combination[4] = 5;  // 0, 1 2 4 5
      if(4==4)
      {
       printf();  //   1 2 4 5
      }
    }
}

recursion(4) //循环结束

recursion(3)   //之前压栈，现在退栈,结束上次循环,i现在为
5,原因是循环还没有结束
{
    while(5<=5)  //i之前是3
    {
      combination[3] = 5; //0,1 2 5 5
      recursion(4)
    }
}

recursion(4)    //recursion(3)要继续压栈,记录 i=5,还没有
执行完,因为for()还没有结束循环
{
    while(4<=5)
    {
      combination[4] = 4;  // 0, 1 2 5 4
      if(4==4)
      {
        if(k!=4)
      }
    }
}

recursion(4)  // 继续执行循环，直到循环结束
{
    while(5<=5)
    {
      combination[4] = 5;  // 0, 1 2 5 5
      if(4==4)
      {
       if(k!=4)
      }
    }
}

recursion(4) //循环结束
recursion(3) //弹出recursion(3),但循环结束

recursion(2) //之前压栈，现在退栈,结束上次循环,i现在为
3,原因是循环还没有结束
{
    while(3<=5)   //之前是i=2
    {
      combination[2] = 3; // 0,1 3 5 5
      recursion(3);
    }
}
PS:单单函数执行都有156次，实在没有充分完全表达出来,递归过程大家过程应该明白吧

[ 本帖最后由 点线面 于 2011-1-4 15:49 编辑 ]

实验了一下果然是156次，实在想不明白，为什么只有五种结果，那个函数却调用如此离谱的多次，楼主算法没写好吧
如果是为了分享，那是否应该先把代码写好再分享？而不要乱写一个，虽然能实现但却不太值得学习的代码发出来，这样会误导新人

我刚刚写一部分分析过程，希望顺我的分析过程看一看，或者有所收获，归递的确很简洁，不过分析起来一塌胡涂，归递本身效率就是不高，有眼看的，如果LS不怕麻烦，可以自己从头分析一次。

[ 本帖最后由 点线面 于 2011-1-4 16:11 编辑 ]

不见得递归简洁吧？
我改写了一个版主写的穷举组合的代码：

int next_combination(int* pArray, int nLen, int nSel)
{
    if (pArray[nLen - 1] + 1 < nSel)
    {
        ++pArray[nLen - 1];
        return 1;
    }
    else
    {
        int it = 2;
        while (it <= nLen && pArray[nLen - it] + it == nSel)
            ++it;
        if (it <= nLen)
        {
            int i;
            pArray[nLen - it]++;
            for (i = nLen - it + 1; i < nLen; ++i )
                pArray[i] = pArray[i - 1] + 1;
            return 1;
        }
        else
            return 0;
    }
}

#include <stdio.h>

int main()
{
    int arrmap[] = {1, 2, 3, 4, 5};
    int arr[20];
    int len = 4, i;

    for (i = 0; i < len; ++i) arr[i] = i; //初始化数组

    do //枚举组合的循环
    {
        for (i = 0; i < len; ++i) //打印组合
        {
            printf("%d ", arrmap[arr[i]]);
        }
        puts("");
    } while ( next_combination(arr, len, sizeof(arrmap) / sizeof(int)) ); //获取下一个组合
    scanf("%*s");
    return 0;
}

这个程序结构清晰很多啊
不过我是觉得，是楼主写的代码不好，调用这么多次简直有点莫名其妙