如何创建一个包含1000行的大型矩阵&；c中的列？

我编写了一个简单的代码，使用邻接矩阵创建一个有向图，邻接矩阵中随机生成的数字是图的顶点。但我的任务是制作一个包含1000行和1000列的更大矩阵。我的代码生成的矩阵不能超过50*50。如何制作一个大矩阵

这是我创建的代码

int arr[1001][1001];
int main()
{
int i,a,b,j,k,m,n;
scanf("%d%d",&a,&b);
for(i=0;i<b;i++)
{
    m=rand()%100;
    n=rand()%100;
    arr[m-1][n-1]=1;
}
for(j=0;j<a;j++)
{
    for(k=0;k<a;k++)
    {
        printf("%d ",arr[j][k]);
    }
    printf("\n");
}

int-arr[1001][1001]；
int main（）
{
int i，a，b，j，k，m，n；
scanf（“%d%d”、&a和&b）；
对于（i=0；i对于基于堆的数组，请参见下文

int main()
{
    int i,a,b,j,k,m,n;
    scanf("%d%d",&a,&b);
    int** arr = (int**)malloc(1001*sizeof(int*));

    for(i=0;i<1001;++i)
        arr[i]=(int*)malloc(1001*sizeof(int));

    for(i=0;i<b;i++)
    {
        m=rand()%100;
        n=rand()%100;
        arr[m-1][n-1]=1;
    }
    for(j=0;j<a;j++)
    {
        for(k=0;k<a;k++)
        {
            printf("%d ",arr[j][k]);
        }
        printf("\n");
    }

    // memory not freed since the program is ending anyway. In real programs, use free to free the 102 arrays.
}

intmain（）
{
int i，a，b，j，k，m，n；
scanf（“%d%d”、&a和&b）；
int**arr=（int**）malloc（1001*sizeof（int*）；
对于（i=0；i对于基于堆的数组，请参见下文

int main()
{
    int i,a,b,j,k,m,n;
    scanf("%d%d",&a,&b);
    int** arr = (int**)malloc(1001*sizeof(int*));

    for(i=0;i<1001;++i)
        arr[i]=(int*)malloc(1001*sizeof(int));

    for(i=0;i<b;i++)
    {
        m=rand()%100;
        n=rand()%100;
        arr[m-1][n-1]=1;
    }
    for(j=0;j<a;j++)
    {
        for(k=0;k<a;k++)
        {
            printf("%d ",arr[j][k]);
        }
        printf("\n");
    }

    // memory not freed since the program is ending anyway. In real programs, use free to free the 102 arrays.
}

intmain（）
{
int i，a，b，j，k，m，n；
scanf（“%d%d”、&a和&b）；
int**arr=（int**）malloc（1001*sizeof（int*）；
对于（i=0；i，您还可以创建如下平面阵列：

#define MATR(arr, column, row) (arr + column + row*101)

int* arr = (int*)malloc(101*101*sizeof(int));

*MATR(arr, 1, 2) = 123;

然后您只需要一个malloc/free。
您还可以创建如下平面阵列：

#define MATR(arr, column, row) (arr + column + row*101)

int* arr = (int*)malloc(101*101*sizeof(int));

*MATR(arr, 1, 2) = 123;

那么您只需要一个malloc/free。
我建议您的解决方案不使用指向指针的指针数组，它只使用通过某种
#define
方法管理为数组的向量。这样生成代码可能会更快

使用向量解决方案，您只需要释放一个向量，使用指针指向指针的解决方案，您需要释放所有列指针，然后释放“行”指针

在我设置为1的代码中，仅包含您使用变量
a
设置的间隔中包含的数组元素，否则输出可能仅显示包含0的元素

#include <stdio.h>

#define ROWS 1000
#define COLS 1000

#define ARRAY(m,n) [n+m*COLS]

int main()
{
    int i,a,b,j,k,m,n;

    int * arr = malloc(COLS*ROWS*sizeof(*arr));

    if (arr) {
        scanf("%d %d",&a,&b);

        for(i=0;i<b;i++)
        {
            // m=rand()%ROWS; // to set into the full array
            m=rand()%a;
            // m=i; to have a diagonal
            // n=rand()%COLS; // to set into the full array
            n=rand()%a;
            // n=i; to have a diagonal
            arr ARRAY(m,n)=1;
        }

        for(j=0;j<a;j++)
        {
            for(k=0;k<a;k++)
            {
                printf("%d ",arr ARRAY(j,k));
            }
            printf("\n");
        }
        free(arr);
    } else {
        perror("malloc: ");
        return 1;
    }

    return 0;
}

#包括
#定义第1000行
#定义COLS 1000
#定义数组（m，n）[n+m*COLS]
int main（）
{
int i，a，b，j，k，m，n；
int*arr=malloc（COLS*ROWS*sizeof（*arr））；
如果（arr）{
scanf（“%d%d”、&a和&b）；
对于（i=0；i我建议的解决方案，您不使用指向指针的指针数组，它只使用通过某种
#define
管理为数组的向量。这样生成代码可能会更快

使用向量解决方案，您只需要释放一个向量，使用指针指向指针的解决方案，您需要释放所有列指针，然后释放“行”指针

在我设置为1的代码中，仅包含您使用变量
a
设置的间隔中包含的数组元素，否则输出可能仅显示包含0的元素

#include <stdio.h>

#define ROWS 1000
#define COLS 1000

#define ARRAY(m,n) [n+m*COLS]

int main()
{
    int i,a,b,j,k,m,n;

    int * arr = malloc(COLS*ROWS*sizeof(*arr));

    if (arr) {
        scanf("%d %d",&a,&b);

        for(i=0;i<b;i++)
        {
            // m=rand()%ROWS; // to set into the full array
            m=rand()%a;
            // m=i; to have a diagonal
            // n=rand()%COLS; // to set into the full array
            n=rand()%a;
            // n=i; to have a diagonal
            arr ARRAY(m,n)=1;
        }

        for(j=0;j<a;j++)
        {
            for(k=0;k<a;k++)
            {
                printf("%d ",arr ARRAY(j,k));
            }
            printf("\n");
        }
        free(arr);
    } else {
        perror("malloc: ");
        return 1;
    }

    return 0;
}

#包括
#定义第1000行
#定义COLS 1000
#定义数组（m，n）[n+m*COLS]
int main（）
{
int i，a，b，j，k，m，n；
int*arr=malloc（COLS*ROWS*sizeof（*arr））；
如果（arr）{
scanf（“%d%d”、&a和&b）；
对于（i=0；i
您只打印一个
a*a
矩阵
如前所述，您将需要动态内存分配
因此，您可以分配
a*a
矩阵，而不需要分配
1001*1001
矩阵
1的设置
已被修改，以阻止越界错误和
-1的索引
使用
calloc
的内存分配调用将矩阵初始化为零
修改后的代码如下

int main(void)
{
    int **arr;    
    int i,a,b,j,k,m,n;
    scanf("%d%d",&a,&b);
    arr = malloc (sizeof(int*) * a);
    for (i=0; i<a; i++)
    {
        arr[i] = calloc(a,sizeof(int));
    }
    for(i=0;i<b;i++)
    {
        m=rand()%a;
        n=rand()%a;
        arr[m][n]=1;
    }
    for(j=0;j<a;j++)
    {
        for(k=0;k<a;k++)
        {
            printf("%d ",arr[j][k]);
        }
        printf("\n");
    }
    return 0;
}

int main（无效）
{
int**arr；
int i，a，b，j，k，m，n；
scanf（“%d%d”、&a和&b）；
arr=malloc（sizeof（int*）*a）；
对于（i=0；i
您只打印一个
a*a
矩阵
如前所述，您将需要动态内存分配
因此，您可以分配
a*a
矩阵，而不需要分配
1001*1001
矩阵
1的设置
已被修改，以阻止越界错误和
-1的索引
使用
calloc
的内存分配调用将矩阵初始化为零
修改后的代码如下

int main(void)
{
    int **arr;    
    int i,a,b,j,k,m,n;
    scanf("%d%d",&a,&b);
    arr = malloc (sizeof(int*) * a);
    for (i=0; i<a; i++)
    {
        arr[i] = calloc(a,sizeof(int));
    }
    for(i=0;i<b;i++)
    {
        m=rand()%a;
        n=rand()%a;
        arr[m][n]=1;
    }
    for(j=0;j<a;j++)
    {
        for(k=0;k<a;k++)
        {
            printf("%d ",arr[j][k]);
        }
        printf("\n");
    }
    return 0;
}

int main（无效）
{
int**arr；
int i，a，b，j，k，m，n；
scanf（“%d%d”、&a和&b）；
arr=malloc（sizeof（int*）*a）；
对于（i=0；i您可以这样声明您的数组：
int-arr[1001][1001]；
只要您不将它放在堆栈上，这是非常好的。既然您全局声明它，一切都应该正常

但您使用阵列的方式不合适：

m=rand()%100;
n=rand()%100;
arr[m-1][n-1]=1;

此处
m
和
n
的值范围为
0…99
。当
m
和
n
均为零时，您的数组设置将变为：

arr[-1][-1]=1;

你会得到未定义的行为

可能（取决于您的用例），asignement应该是这样的

arr[m][n] = 1;

你可以这样声明你的数组：
int-arr[1001][1001]；
只要你不把它放在堆栈上就可以了。既然你全局声明了它，一切都应该是正常的

但您使用阵列的方式不合适：

m=rand()%100;
n=rand()%100;
arr[m-1][n-1]=1;

此处
m
和
n
的值范围为
0…99
。当
m
和
n
均为零时，您的数组设置将变为：

arr[-1][-1]=1;

你会得到未定义的行为

可能（取决于您的用例），asignement应该是这样的

arr[m][n] = 1;

您使用的编译器是什么？可能是堆栈大小有限。请尝试通过malloc在堆上分配此数组。它是CodeBlocks软件中内置的GNU CCC编译器。我在代码中看不到任何图形。
m-1
不正确！
m=rand（）%100
可能会导致0，那么m将是-1。您使用的编译器是什么？堆栈大小可能有限。请尝试通过malloc在堆上分配此数组。它是在CodeBlocks软件中内置的GNU CCC编译器。我在代码中看不到任何图形。
m-1
不正确！
m=rand（）%100
可能会导致0，那么m将是-1。感谢代码清除malloc的使用。但是，您的代码无法生成一个大矩阵。它创建的矩阵不超过60*60。那么，您的系统/编译器出现了其他问题。此代码应该在堆上创建1001个int数组，它会。我正在使用GNU CCC CompilerYou不能使用m-1和n-1 a