打印C中整数数组的所有递减组合

我有一个整数数组，我需要打印所有可能的递减组合，它们以最大的数字开始。下面是一个例子：

int array[MAX_LEN]={ 5 , 4 , 3 , 2 , 1 }

以及预期产量:

5 , 4 , 3 , 2 , 1  
5 , 4 , 3 , 2   
5 , 4 , 3 , 1  
5 , 4 , 2 , 1  
5 , 3 , 2 , 1  
5 , 2 , 1  
.  
.  
5 , 1  
.  
.  
5  

---

有人能给我一个建议怎么做吗？谢谢

这个问题可以表示为“对于[4,3,2,1]打印5中的每一个，然后是子序列”

要查找所有子序列，可以按照以下方式执行操作

findAllSubsequences(array) {
    if (array is empty)
        return an empty list

    result = new list

    head = array[0]      // 4
    tail = array[1...]   // [3, 2, 1]

    tailSubsequences = findAllSubsequences(tail)  // recurse on tail

    // Add all subsequences that don't include head
    // [3,2,1] [3,1] [2,1] ...
    result.addAll(tailSubsequences)

    // Add all subsequences that do include head
    // [4,3,2,1] [4,3,1] [4,2,1] ...
    for each subsequence s in tailSubsequences
        result.add(head concatenated with s)

    return result
}

---

要一次显示n个内容3，可以使用3个索引循环：

    for(i = 0; i < n-3; i++)
        for(j = i+1; j < n-2; j++)
            for(k=j+1; k < n-1; k++)
                // display array[i], array[j], array[k]

（i=0；i 对于（j=i+1；j 为了将其推广到每次为k=1到n个对象显示n个对象（这是外循环），使用迭代（循环非递归）方法，您可以使用索引数组，如ai[n]。然后，对于每次k个对象，您需要用代码替换嵌套循环，这些代码使用k个索引（从ai[0]=0，ai[1]=1，…）完成相同的任务。。。ai[k-1]=k-1。指数的范围将是ai[0]从0到n-k，ai[1]从ai[0]+1到n-k+1，…，ai[k-1]从ai[k-2]+1到n-1。索引像里程表一样先进，ai[k-1]是最低有效数字，ai[0]是最高有效数字

这将为您提供所有的组合。如果需要按降序排列，可以对原始数组排序，也可以对原始数组的副本排序

此类函数的通用名称为“下一个组合”。示例代码：

#include <stdio.h>
#include <malloc.h>

int next_combination(size_t *I, size_t k, size_t n)
{
size_t i, j;
    i = k-1;                            /* find next element to increment */
    while(I[i] == (n-k+i)){
        --i;
        if(i == (size_t)-1){            /* if done, */
            for(i = 0; i < k;  i++)     /*  return initial combination */
                I[i] = i;
            return(0);
        }
    }
    I[i] += 1;                          /* increment element */
    for(j = i+1; j < k; j++)            /* create increasing string */
            I[j] = I[i]+j-i;
    return(1);                          /* return with new combination */
}

int main(int argc, char **argv)
{
int    A[5] = {5, 4, 3, 2, 1};
size_t I[5];
size_t i, k, n;
    n = sizeof(A)/sizeof(A[0]);         /* n things */
    for(k = n; k; k--){                 /* n things k at a time */
        for(i = 0; i < k;  i++)         /* create initial combination */
            I[i] = i;
        do{                             /* display combinations */
            for(i = 0; i < k; i++)
                printf("%2d", A[I[i]]);
            printf("\n");
        }
        while(next_combination(I, k, n));
    }
    return(0);
}

#包括
#包括
整数下一个组合（大小\t*I、大小\t k、大小\t n）
{
尺寸i，j；
i=k-1；/*查找要递增的下一个元素*/
而（I[I]==（n-k+I））{
--一,；
如果（i==（size_t）-1）{/*如果完成*/
对于（i=0；i

常见和必要的问题：从一个简单的例子开始：比如{3,2,1}。用手写出符合逻辑的组合。你应该看到一种模式出现。你会意识到你需要两个循环，内部循环的边界取决于外部循环。@Bathsheba，我想说用循环解决这个问题很难。（不能添加n个循环。）必须跟踪索引堆栈。@Bathsheba O（n^2）不正确。我想看看你的证据。因为它不正确，所以没有证据可看；）