Thread: Help in swapping matrix rows.

I'm not entirely sure what you mean by "connect the matrix with it".
You could add an extra column and put the sum there.

Code:

#include <stdio.h>
#include <stdlib.h>
 
#define ROWS 4
#define COLS 4   // one extra to hold the sum
 
// Compare function for qsort, sorting rows by last column.
int cmp(const void *a, const void *b) {
    return ((int*)a)[COLS-1] - ((int*)b)[COLS-1];
}
 
int main() {
    int m[ROWS][COLS] = {
        { 5, 2, 3, 0 },  // init sum column to 0
        { 6, 5, 8, 0 },
        { 9, 2, 7, 0 },
        { 8, 9, 8, 0 }
    };
 
    // Calculate sums.
    for (int r = 0; r < ROWS; ++r)
        for (int c = 0; c < COLS - 1; ++c)
            m[r][COLS-1] += m[r][c];
 
    // Sort.
    qsort(m, ROWS, sizeof m[0], cmp);
 
    // Print.
    for (int r = 0; r < ROWS; ++r) {
        for (int c = 0; c < COLS; ++c)
            printf("%2d ", m[r][c]);
        putchar('\n');
    }
 
    return 0;
}

That makes no difference: you can still have an additional column for the sum.

If you're adamant about having a matrix such that the sum is not part of it, then assuming your matrix is in row-major order, you can take an index approach: declare a struct consisting of a pointer and a number. The pointer will point to the first entry in a row of the matrix; the number will be the sum of the entries of that row. You then create an array of these struct objects and sort them according to the sums. The result is that you will have the row pointers in sorted order according to the sum, and so this array will serve as an index to the matrix to access it in sorted order according to the sum of each row.

If you cannot add a new column and you cannot create another array, then you must implement the sort yourself because you then cannot use qsort to do what you want.

Originally Posted by amohammed63

If you don't mind, what's the problem with this part from my code?

What is that code supposed to do and how does it not work?

Ah. To swap the rows of the matrix, use memcpy with a temporary array. It's easier than writing your own loop. If you must write your own loop, then the swapping will mirror the swapping of the sums: presently you're inexplicably involving j-1 in your swap, but that expression doesn't appear when you're swapping the sums.

To implement the sort, first implement the sort to sort the sums only. Compile and test to see it if works as expected. When you're sure that works, only then do you add the code to swap the corresponding rows of the matrix.

I repeat my advice from my previous post: to implement the sort, first implement the sort to sort the sums only. Compile and test to see it if works as expected. When you're sure that works, only then do you add the code to swap the corresponding rows of the matrix. The code to swap the corresponding rows of the matrix should mirror the code to swap the sums when sorting them, e.g., if you're swapping y[i] and y[j], then likewise you will swap x[i] and x[j], not x[j-1] and x[j].

By the way, x and y aren't very descriptive names. I would rename x to matrix (or if you have an even better name concerning what the matrix is for, use that) and y to sums or row_sums.