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

Question

你能帮我想办法实现我的程序吗？在这个程序中，我需要找到矩阵的最小值，比较它们，然后找到最大的最小值。我是用指针做的<是否还有另一种变体可以在没有指针和结构的情况下找到最小值？我想，我可以使用全局变量，如果我是对的，你能支持我吗？谢谢... 这是我的代码和指针...

#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 "arrays" 尝试这段代码时，它们三个都具有相同的元素！这是因为您已将对 srand() 的调用置于 numbers_for_my_array() 函数内。此函数被快速连续调用三次，因此 rand() 每次都使用相同的值作为种子。 time() 返回的值在这个短时间间隔内没有改变。您只需要调用 srand() 一次，并且您应该在 main().

的开头进行调用

您对第三个 "array" 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 任何内存分配。规则是，每次调用 malloc():

一个 free

/* 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 为每个 "array".

分配的内存

您应该考虑使用 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 的二维数组似乎是一个合理的选择。当然，numbers_for_my_array() 函数会更改数组，但 print_my_array() 和 min_my_array() 不会。在这些函数原型中声明 const int arr[rows][cols] 会很好。棘手的部分是，这些数组在函数调用中衰减为指针，而 C 会将 ints 的一维数组转换为 const ints 的数组（因为数组衰减为指针到 int，它被转换为指向 const int 的指针），它将在将 int 的二维数组转换为 const int 的二维数组时发出警告。。代码仍然可以编译，但要消除警告，您需要进行丑陋的强制转换，以将类型显式强制转换为函数所期望的类型：

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 而修改的程序；此版本确实在 print_my_array() 和 min_my_array() 函数中使用了 const int 数组：

#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;}

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

find min. value in several matrix without pointer

c

algorithm

matrix

min