找到分钟。没有指针的几个矩阵中的值

Question

你可以帮我找一个方案吗？在这个程序中，我需要找到我的矩阵的最小值，并比较它们，然后找到最大的最小值。我用指针做了它＆lt;是否还有一个变量来找到没有指针和结构的最小值？我想，我可以使用全局变量，如果我是对的，你能支持我吗？谢谢... 这是我的代码指针...

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

int ch_data(const int,const int,const int,const int);
int** my_array(const int,const int);
void numbers_for_my_array(int** const,const int,const int);
void print_my_array(int** const,const int, const int);
void min_my_array(int** const ,const int ,const int, int*, int*, int*);
int my_mod(int);
int comp_my_array (int,int,int);



int main()
{
    int N,M,L,K,**a=NULL,**b=NULL,**c=NULL,B;

    printf("%s",read);
    while (1){
    printf("Enter N: ");
    scanf("%d",&N);
    printf("Enter M: ");
    scanf("%d",&M);
    printf("Enter L: ");
    scanf("%d",&L);
    printf("Enter K: ");
    scanf("%d",&K);
    printf("\n\n");

        if (ch_data(N,M,L,K)){
        break;
        }
    }


    int* min_i_a_p, *min_j_a_p, *min_value_a_p;
    int* min_i_b_p, *min_j_b_p, *min_value_b_p;
    int* min_i_c_p, *min_j_c_p, *min_value_c_p;

    int min_i_a = 0, min_j_a = 0, min_value_a = 0;
    int min_i_b = 0, min_j_b = 0, min_value_b = 0;
    int min_i_c = 0, min_j_c = 0, min_value_c = 0;

    min_i_a_p = &min_i_a;
    min_j_a_p = &min_j_a;
    min_i_b_p = &min_i_b;
    min_j_b_p = &min_j_b;
    min_i_c_p = &min_i_c;
    min_j_c_p = &min_j_c;

    min_value_a_p = &min_value_a;
    min_value_b_p = &min_value_b;
    min_value_c_p = &min_value_c;


    a=my_array(N,M);
    numbers_for_my_array(a,N,M);
    print_my_array(a,N,M);
    min_my_array(a, N, M, min_i_a_p, min_j_a_p, min_value_a_p);

    b=my_array(M,L);
    numbers_for_my_array(b,M,L);
    print_my_array(b,M,L);
    min_my_array(b, M, L, min_i_b_p, min_j_b_p, min_value_b_p);

    c=my_array(L,K);
    numbers_for_my_array(c,L,K);
    print_my_array(c,L,K);
    min_my_array(b, M, L, min_i_c_p, min_j_c_p, min_value_c_p);

    printf("min of a[%d][%d]- %d \n", *min_i_a_p, *min_j_a_p, *min_value_a_p);
    printf("min of b[%d][%d]- %d \n", *min_i_b_p, *min_j_b_p, *min_value_b_p);
    printf("min of c[%d][%d]- %d \n", *min_i_c_p, *min_j_c_p, *min_value_c_p);

     B=comp_my_array(*min_value_a_p, *min_value_b_p,*min_value_c_p);

    printf("B = %d",B);



    return 0;
}

int ch_data(int N,int M, int L,int K){
    if((N*M<=300)&&(M*L<=300)&&(K*L<=300)){
        return 1;
    }
    else return 0;
}

int** my_array(const int x, const int y){
    int **array=NULL,i;
    if(!(array=(int**)malloc(x*sizeof(int*)))){
        printf("Error memory");
        exit(0);
        }
    for(i=0;i<x;i++){
        if(!(*(array+i)=(int*)malloc(y*sizeof(int)))){
            printf("Error memory");
            exit(0);
        }
    }
return array;
}

void numbers_for_my_array( int** const a ,const int x,const int y){
    srand(time(NULL));
    int i,j;
    for (i=0;i<x;i++){
        for(j=0;j<y;j++){
            a[i][j]=rand()%100;
        }
    }

}

void print_my_array (int** const array, const int x, const int y)
{
    int i, j;
    for(i=0;i<x;i++)
    {
        for(j=0;j<y;j++)
        {
            printf("%d ", array[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

void min_my_array (int** const a,const int N,const int M, int* min_i, int* min_j, int* min_value)
{
    int i, j,min_a;
    min_a=a[0][0];
    *min_value = min_a;
    for(i=0;i<N;i++)
    {
        for(j=0;j<M;j++)
        {
            if (my_mod(a[i][j])<min_a)
            {
                min_a = my_mod(a[i][j]);
                *min_value = a[i][j];
                *min_i = i;
                *min_j = j;
                *min_value=min_a;
            }
        }
    }
}

int comp_my_array (int min_value_a,int min_value_b,int min_value_c){

    int s1,s2,s3;
    s1=min_value_a;
    s2=min_value_b;
    s3=min_value_c;
    return (s1> s2)? ((s1>s3)? s1 : s3) : ((s2 > s3)? s2 : s3);
}

int my_mod(int x){
    return (x>=0)? x:-x;}

Answer 1

首先，您的程序无法编译。这很容易解决，可能是拼写错误的结果。在main()的开头，你有：

printf("%s", read);

但是read未定义，我不知道你想在这里打印什么。删除此语句（或定义read）可以解决此问题。

接下来，当我用3X3＆＃34;数组＆＃34;尝试这个代码时，他们三个都有相同的元素！这是因为您已将srand()调用放在numbers_for_my_array()函数中。此函数快速连续调用三次，因此rand()每次都以相同的值播种。 time()返回的值在此短时间间隔内未发生变化。您只需拨打一次srand()，就应该在main()的开头进行。

处理第三个＆＃34;数组时出错？＃34; c。你需要改变：

min_my_array(b, M, L, min_i_c_p, min_j_c_p, min_value_c_p);

为：

min_my_array(c, L, K, min_i_c_p, min_j_c_p, min_value_c_p);

您有内存泄漏，因为您在程序结束时没有free任何内存分配。对于free的每次调用，规则是malloc()：

/* Free allocated memory */
for (int i = 0; i < N; i++) {
    free(a[i]);
}
free(a);

for (int i = 0; i < M; i++) {
    free(b[i]);
}
free(b);

for (int i = 0; i < L; i++) {
    free(c[i]);
}
free(c);

您可以将此功能包含在一个小函数中，以free为每个＆＃34;数组＆＃34;分配的内存。

您应该考虑将size_t用于array dimensions and indices。它是一个无符号整数类型，保证保存任何数组索引值。

现在，您使用动态分配创建的不是数组，而是模拟数组。这种技术容易出错，您可以轻松地结束内存泄漏（就像您一样）。您应该为此使用可变长度数组（VLA）。这些都很容易使用，并且由于它们具有自动存储持续时间，因此不需要重新分配。

要将代码转换为使用VLA，可以删除my_array()函数，并更改这些函数签名：

void numbers_for_my_array(const int rows, const int cols, int arr[rows][cols]);
void print_my_array(const int rows, const int cols, int arr[rows][cols]);
void min_my_array(const int rows, const int cols, int arr[rows][cols], int *min_i, int *min_j, int *min_val);

使用VLA的函数要求在函数原型的参数中，在VLA本身出现之前声明指定VLA维度的变量。

然后，您将在以下函数中使用这些VLA：

int a[N][M];
numbers_for_my_array(N, M, a);
print_my_array(N, M, a);
min_my_array(N, M, a, min_i_a_p, min_j_a_p, min_value_a_p);

将代码转换为VLA有一个棘手的方面：您拥有的动态数组是指向const值的指针，因此const int的2D数组似乎是一个合理的选择。当然，numbers_for_my_array()函数会更改数组，但print_my_array()和min_my_array()不会。在这些函数原型中声明const int arr[rows][cols]会很高兴。棘手的部分是，这些数组在函数调用中衰减为指针，而C将int的1D数组转换为const int s的数组（因为数组衰减为指针转换为int指针的const int，将int的2D数组转换为const int的2D数组时会发出警告。 Here is a link that discusses the issue in more detail.。代码仍然编译，但要摆脱警告，你需要做一个丑陋的演员，以明确地将类型转换为函数所期望的：

print_my_array(N, M, (const int (*)[M]) a);
min_my_array(N, M, (const int (*)[M]) a, min_i_a_p, min_j_a_p, min_value_a_p);

或者你可以完全放弃const限定符，如果这对你来说太难看了。

这应该可以让你简化你的代码，而不会有更多的内存分配问题！作为旁注，最好使用一个带有多个参数的函数，在函数原型中使用变量名来记录函数的使用。

这是您修改为使用VLA的程序;此版本确实使用const int和print_my_array()函数中的min_my_array()数组：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int ch_data(const int,const int,const int,const int);
void numbers_for_my_array(const int rows, const int cols, int arr[rows][cols]);
void print_my_array(const int rows, const int cols, const int arr[rows][cols]);
void min_my_array(const int rows, const int cols, const int arr[rows][cols], int *min_i, int *min_j, int *min_val);
int my_mod(int);
int comp_my_array (int,int,int);



int main()
{
    int N, M, L, K, B;

    srand(time(NULL));              // moved from numbers_for_my_array()

    while (1){
        printf("Enter N: ");
        scanf("%d",&N);
        printf("Enter M: ");
        scanf("%d",&M);
        printf("Enter L: ");
        scanf("%d",&L);
        printf("Enter K: ");
        scanf("%d",&K);
        printf("\n\n");

        if (ch_data(N,M,L,K)){
            break;
        }
    }


    int* min_i_a_p, *min_j_a_p, *min_value_a_p;
    int* min_i_b_p, *min_j_b_p, *min_value_b_p;
    int* min_i_c_p, *min_j_c_p, *min_value_c_p;

    int min_i_a = 0, min_j_a = 0, min_value_a = 0;
    int min_i_b = 0, min_j_b = 0, min_value_b = 0;
    int min_i_c = 0, min_j_c = 0, min_value_c = 0;

    min_i_a_p = &min_i_a;
    min_j_a_p = &min_j_a;
    min_i_b_p = &min_i_b;
    min_j_b_p = &min_j_b;
    min_i_c_p = &min_i_c;
    min_j_c_p = &min_j_c;

    min_value_a_p = &min_value_a;
    min_value_b_p = &min_value_b;
    min_value_c_p = &min_value_c;

    int a[N][M];
    numbers_for_my_array(N, M, a);
    print_my_array(N, M, (const int (*)[M]) a);
    min_my_array(N, M, (const int (*)[M]) a, min_i_a_p, min_j_a_p, min_value_a_p);

    int b[M][L];
    numbers_for_my_array(M, L, b);
    print_my_array(M, L, (const int (*)[L]) b);
    min_my_array(M, L, (const int (*)[L]) b, min_i_b_p, min_j_b_p, min_value_b_p);

    int c[L][K];
    numbers_for_my_array(L, K, c);
    print_my_array(L, K, (const int (*)[K]) c);
    min_my_array(L, K, (const int (*)[K]) c, min_i_c_p, min_j_c_p, min_value_c_p);

    printf("min of a[%d][%d]- %d \n", *min_i_a_p, *min_j_a_p, *min_value_a_p);
    printf("min of b[%d][%d]- %d \n", *min_i_b_p, *min_j_b_p, *min_value_b_p);
    printf("min of c[%d][%d]- %d \n", *min_i_c_p, *min_j_c_p, *min_value_c_p);

    B=comp_my_array(*min_value_a_p, *min_value_b_p,*min_value_c_p);

    printf("B = %d\n",B);

    return 0;
}

int ch_data(int N,int M, int L,int K){
    if((N*M<=300)&&(M*L<=300)&&(K*L<=300)){
        return 1;
    }
    else return 0;
}

void numbers_for_my_array(const int rows, const int cols, int arr[rows][cols])
{
    int i,j;
    for (i=0;i<rows;i++){
        for(j=0;j<cols;j++){
            arr[i][j]=rand()%100;
        }
    }

}


void print_my_array(const int rows, const int cols, const int arr[rows][cols])
{
    int i, j;
    for(i=0;i<rows;i++)
    {
        for(j=0;j<cols;j++)
        {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

void min_my_array(const int rows, const int cols, const int arr[rows][cols], int *min_i, int *min_j, int *min_value)
{
    int i, j,min_a;
    min_a=arr[0][0];
    *min_value = min_a;
    for(i=0;i<rows;i++)
    {
        for(j=0;j<cols;j++)
        {
            if (my_mod(arr[i][j])<min_a)
            {
                min_a = my_mod(arr[i][j]);
                *min_value = arr[i][j];
                *min_i = i;
                *min_j = j;
                *min_value=min_a;
            }
        }
    }
}

int comp_my_array (int min_value_a,int min_value_b,int min_value_c){

    int s1,s2,s3;
    s1=min_value_a;
    s2=min_value_b;
    s3=min_value_c;
    return (s1> s2)? ((s1>s3)? s1 : s3) : ((s2 > s3)? s2 : s3);
}

int my_mod(int x){
    return (x>=0)? x:-x;}