逻辑高手请进：求do...while的通用算法

有如下代码片段：
           if (n == 2)
           {
               for (int i = 0; i < m - n + 1; i++)
               {
                   for (int j = i + 1; j < m - n + 2; j++)
                   {
                           juzhen[counter, 0] = i + 1;
                           juzhen[counter, 1] = j + 1;
                           counter++;
                   }
               }
           }
           if (n == 3)
           {
               for (int i = 0; i < m - n + 1; i++)
               {
                   for (int j = i + 1; j < m - n + 2; j++)
                   {
                       for (int k = j + 1; k < m - n + 3; k++)
                       {
                           juzhen[counter, 0] = i + 1;
                           juzhen[counter, 1] = j + 1;
                           juzhen[counter, 2] = k + 1;
                           counter++;
                       }                   }
               }
           }           ......其中n是任意正整数，大家发现for语句和循环体内的语句会随着n的增加而增加，以上是很笨的算法，现在求用do...while替换for循环的通用算法，以适应n不断变化的情况，小弟想了很多天，也没想出来，麻烦各位高手帮想一下

解决方案 »

  1.   

    你的juzhen是2维的，如果值是连续的数字的话，应该不用这么多循环的。
      

  2.   

    你的循环可以展开
    for (int i = 0; i < m - n + 1; i++) 
    { 
      for (int j = i + 1; j < m - n + 2; j++) 
      { 
        for (int k = j + 1; k < m - n + 3; k++) 
        { 
          juzhen[counter, 0] = i + 1; 
          juzhen[counter, 1] = j + 1; 
          juzhen[counter, 2] = k + 1; 
          counter++; 
        } 
      } 
    } 
    其实就是 
    for (int i = 0; i < (m - 2) * (m - 1) * m; i++)
    {
        int n2 = i % n;
        juzhen[i, 1] = i + 1 + (i / n) * Math.Pow(n2);
    }
      

  3.   

    p.s. (m - 2) * (m - 1) * m 这个也可以写为一个算式。
      

  4.   

                for (int i = 0; i < m - n + 1; i++)
                {
                    for (int j = i + 1; j < m - n + 2; j++)
                    {
                        for (int k = 0; k < n; k++)//加上这句就可以了...
                        {
                            juzhen[counter, 0] = i + 1;
                            juzhen[counter, 1] = j + 1;
                            counter++;
                        }
                    }
                }
      

  5.   


    好像不太对哦，反映不出n变化的情况，再说juzhen里的第二维是随着n变化的。
      

  6.   

    其实我的目的是：遍历m个数内的所有n个数的组合，如：m=5,n=3则有：
    123，124，125，134，135，145，234，235，245，345
    而当m=5,n=4时则有：
    1234，1235，1245，1345，2345
      

  7.   

    int counter = 0;
    int[,] juzhen = new int[10000000, 10000000];
    int m = 99;
    int[] ijks;//ijks.Length == n
    int mn;// m - n
    void DoCalculate(int n)
    {
    ijks = new int[n];
    for (int i = 0; i < n; i++)
    ijks[i] = i;
    mn = m - n;
    bool touchedEnd = false;
    while (!touchedEnd)
    {
    for (int i = 0; i < n; i++)
    juzhen[counter, i] = ijks[i] + 1;
    counter++; touchedEnd = !UpdateIjks();
    }
    }
    bool UpdateIjks()
    {
    for (int i = 1; i <= ijks.Length; i++)
    {
    int xIndex = ijks.Length - i;//from the last to the first
    if (ijks[xIndex] < mn + i)
    {
    //set new values
    ijks[xIndex]++;
    if (xIndex < ijks.Length - 1)
    {//init the following ijks
    for (int j = xIndex + 1; j < ijks.Length; j++)
    ijks[j] = ijks[j - 1] + 1;
    }
    return true;
    }
    }
    return false;
    }
      

  8.   


    int counter = 0;
    int[,] juzhen = new int[10000000, 10000000];
    int m = 99;
    int[] ijks;//ijks.Length == n
    int mn;// m - n //main function
    void DoCalculate(int n)
    {
    ijks = new int[n];
    for (int i = 0; i < n; i++)
    ijks[i] = i;
    mn = m - n;
    bool touchedEnd = false;
    while (!touchedEnd)
    {
    for (int i = 0; i < n; i++)
    juzhen[counter, i] = ijks[i] + 1;
    counter++; touchedEnd = !UpdateIjks();
    }
    } //sub function
    bool UpdateIjks()
    {
    for (int i = 1; i <= ijks.Length; i++)
    {
    int xIndex = ijks.Length - i;//from the last to the first
    if (ijks[xIndex] < mn + i)
    {
    //set new values
    ijks[xIndex]++;
    if (xIndex < ijks.Length - 1)
    {//init the following ijks
    for (int j = xIndex + 1; j < ijks.Length; j++)
    ijks[j] = ijks[j - 1] + 1;
    }
    return true;
    }
    }
    return false;
    }
      

  9.   

    int counter = 0;
    int[,] juzhen = new int[10000000, 10000000];
    int m = 99;
    int[] ijks;//ijks.Length == n
    int mn;// m - n //main function
    void DoCalculate(int n)
    {
    ijks = new int[n];
    for (int i = 0; i < n; i++)
    ijks[i] = i;
    mn = m - n;
    bool touchedEnd = false;
    while (!touchedEnd)
    {
    for (int i = 0; i < n; i++)
    juzhen[counter, i] = ijks[i] + 1;
    counter++; touchedEnd = !UpdateIjks();
    }
    } //sub function
    bool UpdateIjks()
    {
    for (int i = 1; i <= ijks.Length; i++)
    {
    int xIndex = ijks.Length - i;//from the last to the first
    if (ijks[xIndex] < mn + i)
    {
    //set new values
    ijks[xIndex]++;
    if (xIndex < ijks.Length - 1)
    {//init the following ijks
    for (int j = xIndex + 1; j < ijks.Length; j++)
    ijks[j] = ijks[j - 1] + 1;
    }
    return true;
    }
    }
    return false;
    }代码咋这么乱呢？
      

  10.   

    写代码不行，就给你写个过程吧
    建立一个tree数据结构，root是0；变量i，j=0
    i++，用for循环为root加1到m个节点，值为1到m；
    然后为root的每个节点重新执行这个代码（就是递归）
    tree tree = new tree();
    function test(i,n,m,root){
        for(var j=1;j<=m;j++){
          node nd = roo.add(j);
          if(i<n){
            test(i+1,n,m,nd);
          }
        }  
    }
    调用test(0,n,m,tree.root);
    然后遍历所有叶子的全路径，就可以得到你要的结果
    比较仓促，没有进行边界教研，仅供参考
      

  11.   

    感谢这么多位大虾的帮助，今天要结帖了，顶者皆有分。
    经过几天的冥思苦想，我自己也找到了解决的方法，还是用for循环，不过效率比递归还低，但也不失为一种比较简洁的解决办法。以下就是具体的代码：
    public int[,] GetCombination(int m, int n)
           {
               int t = 1;
               int c = 0;
               int zh = combination(m, n);    //combination函数是求c(m,n)的组合数
               int[,] juzhen = new int[zh, n];
               int[] temp = new int[n];
               for (int i = 1; i <= m - n + t; i++)
               {
                   temp[t - 1] = i;
                   if (t < n)
                   {
                       t++;
                       continue;
                   }
                   else
                   {
                       for (int j = 0; j < n; j++)
                       {
                           juzhen[c, j] = temp[j];
                       }
                       c++;
                       for (int k = 1; k < n; k++)
                       {
                           if (temp[k] == m - n + k + 1)
                           {
                               i = temp[k - 1];
                               t = k;
                               break;
                           }
                       }
                       continue;
                   }
               }
               return juzhen;
           }另外,也贴出递归的算法，以作比较：
    其中juzhen和counter是公有的变量
    public int[,] GetCombination(int m, int n)
           {
               for (int i = start; i <= m - n + t; i++)
                { 
                    a[t-1] = i;
                    if (t < n)
                    {
                        GetCombination(m, n, i + 1, t + 1);
                    }
                    else
                    {
                        for (int j = 0; j < n; j++)
                        {
                            juzhen[counter, j] = a[j];
                        }
                        counter++;
                    }      
                }
           }