Find the column with the maximum negative matrix element and the column with the minimum element-CodePudding

I want to know the column with the maximum negative matrix element and the column with the minimum element so that I can rearrange them. More specifically, I'm interested in return values of The column with the maximum negative element: and The column with the minimum element: But about half the time, the results about which columns they are return completely wrong. The interesting thing is that the results don't always come back wrong. What am I doing wrong?

#include <iostream>
#include <time.h>
#include <cmath>

using namespace std;

int main(void) {

    // random number for rand()
    srand(time(0));

    int m = 5;  // row count
    int n = 5;  // column count

    // declaration of a dynamic array of pointers
    double **arr = (double**) malloc(n * sizeof(double));

    // filling the array with pointers
    for (int i = 0; i < n; i  )
        arr[i] = (double*) malloc(m * sizeof(double));

    // array initialization with random numbers
    for (int i = 0; i < n; i  )
        for (int j = 0; j < m; j  )
            arr[i][j] = (double) (rand() % 400 - 199) / 2.0;    // (-100.0; 100.0)

    // matrix output
    cout << "\n\033[92mOriginal array:\033[94m" << endl;
    for (int i = 0; i < m; i  ) {
        for (int j = 0; j < n; j  )
            printf("%5.1f ", arr[i][j]);
        cout << endl;
    }



    // array for the sums of modules of the row elements
    float *sumOfAbsolutes = (float*) malloc(m * sizeof(float));

    // Initializing the array with zeros
    for (int i = 0; i < m; i  ) sumOfAbsolutes[i] = 0;

    // filling the array with the sums of element modules
    for (int i = 0; i < m; i  )
        for (int j = 0; j < n; j  )
            sumOfAbsolutes[i]  = abs(arr[i][j]);

    // output
    cout << "\n\033[92mSums of modules of array row elements:" << endl;
    for (int i = 0; i < m; i  ) 
        cout << "\033[92m" << i << ": \033[94m"<< sumOfAbsolutes[i] << "   ";
    cout << "\n\n";


    // sorting
    for (int i = 0; i < (m - 1); i  )
        for (int j = i; j < m; j  )
            if (sumOfAbsolutes[i] > sumOfAbsolutes[j]) {
                double tmp = sumOfAbsolutes[i];
                sumOfAbsolutes[i] = sumOfAbsolutes[j];
                sumOfAbsolutes[j] = tmp;

                double *tmp2 = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp2;
            }

    // matrix output
    cout << "\033[92mSorted array:\033[94m" << endl;
    for (int i = 0; i < m; i  ) {
        for (int j = 0; j < n; j  )
            printf("%5.1f ", arr[i][j]);
        cout << endl;
    }


    int columnWithMaxNegNum = 0;        // the column with the maximal negative element
    int minNumber = 0;                  // the column with the minimum element

    // search for the maximal negative element
    for (int i = 0; i < m; i  )
        for (int j = 0; j < n; j  )
            if (arr[i][j] < 0 && arr[i][j] > arr[i][columnWithMaxNegNum])
                columnWithMaxNegNum = j;
    
    // minimum element search
    for (int i = 0; i < m; i  )
        for (int j = 0; j < n; j  )
            if (arr[i][j] < arr[i][minNumber]) minNumber = j;


    cout << "\n\033[92mThe column with the maximum negative element: \033[94m" << columnWithMaxNegNum << endl;
    cout << "\033[92mThe column with the minimum element: \033[94m" << minNumber << endl;

    // rearrangement of columns
    for (int i = 0; i < m; i  ) {
        double temp = arr[i][columnWithMaxNegNum];
        arr[i][columnWithMaxNegNum] = arr[i][minNumber];
        arr[i][minNumber] = temp;
    }

    cout << "\n\033[92mRearrangement of columns:" << endl;
    for (int i = 0; i < m; i  ) {
        for (int j = 0; j < n; j  )
            printf("\033[94m%5.1f ", arr[i][j]);
        cout << "\n\033[0m";
    }

    // memory cleanup
    free(sumOfAbsolutes);
    for (int i = 0; i < n; i  )
        free(arr[i]);
    free(arr);
}

CodePudding user response：

I assume that this is some kind of homework, since normally, we'd use vectors and algorithms to write much shorter code.

The following loop doesn't find the maximal negative:

// search for the maximal negative element
for (int i = 0; i < m; i  )
    for (int j = 0; j < n; j  )
        if (arr[i][j] < 0 && arr[i][j] > arr[i][columnWithMaxNegNum])
            columnWithMaxNegNum = j;

Because the the search is dependent of the line. You'd need to go for:

double maxNegNum = -100.0;   // tbd
for (int i = 0; i < m; i  )
    for (int j = 0; j < n; j  )
        if (arr[i][j] < 0 && arr[i][j] > maxNegNum) {
            columnWithMaxNegNum = j;
            maxNegNum = arr[i][j]; 
        }

The same applies for the minimum :

double minN=100.0;
for (int i = 0; i < m; i  )
    for (int j = 0; j < n; j  )
        if (arr[i][j] < minN) {
            minNumber = j;
            minN = arr[i][j];
        }

Not related: if you go for C forget malloc and free, and use new/delete and new[]/delete[] instead. Here a first attempt: Online demo

Caution/Limitations:

If by no negative number are found, the maximum negative value would be inaccurate.
If several equal maximum negative values and minimum values are found, only the first one( from left to right and to bottom) will be considered.