要打印c中矩阵元素的组合吗

我有一个二维矩阵 我想打印第一行和其余行的组合

以下是我尝试过的：

因为解决方案需要通用，所以我使用递归优先处理循环和数字

#include<stdio.h>
int i,n,j,k,row=3,col=3,mat[10][10]={{1,2,3},{4,5,6},{7,8,9}};

int printnumbers(int n,int i)
{
    if(n>=row)
    {
        n=0;
        printf("\n");
        return 0;
    }
    printf("%d",mat[n][i]);
    printnumbers(n+1,i);
}

int printloop(int row,int col)
{
    //to check whether the function is being called first time. 
    if(row<=0)
        return 0;

    for(i=0;i<col;i++)
    {
        printloop(row-1,col);
        printnumbers(n,i);
    }        
}

int main()
{
    n=0;
    printloop(row,col);
}

---

您可以递归地构建解决方案。随着递归的深入，您会不断追加相应矩阵行的编号，直到从每一行中选取一个编号为止

执行此操作时，必须跟踪已为前几行选择的数字，以便打印它们

请不要让循环变量成为全局变量。理想情况下，不要使用任何全局变量，但如果必须，请使它们唯一。在您的示例中，

i

、

n

、

row

和

col

可以是局部变量，也可以是全局变量，具体取决于上下文。很难看出符号真正指的是哪个变量

printnumbers

和

printloop

函数应为

void

或为所有分支返回有意义的值。编译器警告应该告诉您，当执行到达函数末尾时，不会返回任何内容

这是一个不需要全局变量的版本，它将拾取的数字保存在调用函数中分配的辅助缓冲区

buf

中。不过，它不会递归地打印组合

#include <stdio.h>

void printloop(int n, const int mat[n][n], int buf[n], int ix)
{
    int i;

    if (ix == n) {        
        for (i = 0; i < n; i++) printf("%2d", buf[i]);
        putchar('\n');
    } else {
        for (i = 0; i < n; i++) {
            buf[ix] = mat[ix][i];
            printloop(n, mat, buf, ix + 1);
        }
    }    
}

int main()
{
    const int mat[3][3] = {
        {1, 2, 3}, {4, 5, 6}, {7, 8, 9}
    };
    int buf[3];

    printloop(3, mat, buf, 0);

    return 0;
}

#包括
无效打印循环（int n，const int mat[n][n]，int buf[n]，int ix）
{
int i；
如果（ix==n）{
对于（i=0；i

---

（注意：从C99开始，您可以在将数组变量作为参数传递时生成其维度。此参数必须位于数组参数之前。）

实际上，在Golang中使用切片非常简单

使上述解决方案通用

代码如下：

package main

import (
    "fmt"
)

func printElements(input [][]int, buf []int, row int, col int, count int) {
    var i int

    if (count == row) {
        for i=0; i<row; i++ {
            fmt.Print(buf[i])
        }
        fmt.Println() 
    } else {
        for i=0 ; i<col; i++ {
            buf[count] = input[count][i]
            printElements(input,buf,row,col,count+1)
        }
    }
}

func main() {
    var input = [][]int{{1,3,5}, {2,6,7}, {4,8,9}}

    row := len(input)
    col := len(input[0])

    var buf =  make([]int,col)

    printElements(input,buf,row,col,0)  
}

主程序包
进口(
“fmt”
)
func printElements（输入[][]int、buf[]int、行int、列int、计数int）{
变量i int
如果（计数==行）{
对于i=0；i
buf
实际上始终是同一个缓冲区，因为它在main中作为指向
buf
的指针传递。它在位置
ix
处被重复覆盖，因此在打印时它包含当前递归通过矩阵的路径。如果不存储该路径，则以前拾取的值不会是av可在打印组合时使用。然后传递两个维度并调整循环的限制。我希望您知道哪个是哪个。
package main

import (
    "fmt"
)

func printElements(input [][]int, buf []int, row int, col int, count int) {
    var i int

    if (count == row) {
        for i=0; i<row; i++ {
            fmt.Print(buf[i])
        }
        fmt.Println() 
    } else {
        for i=0 ; i<col; i++ {
            buf[count] = input[count][i]
            printElements(input,buf,row,col,count+1)
        }
    }
}

func main() {
    var input = [][]int{{1,3,5}, {2,6,7}, {4,8,9}}

    row := len(input)
    col := len(input[0])

    var buf =  make([]int,col)

    printElements(input,buf,row,col,0)  
}