Sorting matrix columns-CodePudding

I have a matrix 4*5 and I need to sort it by several columns.

Given these inputs:

sort_columns = [3, 1, 2, 4, 5, 2]
matrix = [[3, 1, 8, 1, 9],
          [3, 7, 8, 2, 9],
          [2, 7, 7, 1, 2],
          [2, 1, 7, 1, 9]]

the matrix should first be sorted by the 3nd column (so the values 8, 8, 7, 7), then the sorted result should again be sorted by column 1 (values 3, 3, 2, 2) and so on.

So, after first sorting by column 3, the matrix would be:

and sorting on column 1 then has no effect as the values are already in the right order. The next column, 2, then makes the order:

etc.

After sorting on all the sort_columns numbers, I expect to get the result:

This is my code to sort the matrix:

def sort_matrix_columns(matrix, n, sort_columns):
    for col in sort_columns:
        column = col - 1
        for i in range(n):
            for j in range(i   1, n):
                if matrix[i][column] > matrix[j][column]:
                    temp = matrix[i]
                    matrix[i] = matrix[j]
                    matrix[j] = temp

which is called like this:

sort_matrix_columns(matrix, len(matrix), sort_columns)

But when I do I get the following wrong result:

Why am I getting the wrong order here? Where is my sort implementation failing?

CodePudding user response：

The short answer is that your sort implementation is not stable.

A sort algorithm is stable when two entries in the sorted sequence keep the same (relative) order when their sort key is the same. For example, when sorting only by the first letter, a stable algorithm will always sort the sequence ['foo', 'flub', 'bar'] to be ['bar', 'foo', 'flub'], keeping the 'foo' and 'flub' values in the same relative order. Your algorithm would swap 'foo' and 'bar' (as 'f' > 'b' is true) without touching 'flub', and so you'd end up with ['bar', 'flub', 'foo'].

You need a stable sort algorithm when applying sort multiple times as you do when using multiple columns, because subsequent sortings should leave the original order applied by preceding sort operations when the value in the current column is the same between two rows.

You can see this when your implementation sorts by column 5, after first sorting on columns 3, 1, 2, 4. After those first 4 sort operations the matrix looks like this:

Your implementation then sorts by column 5, so by 9, 9, 2, 9. The first row is then swapped with the 3rd row (2 1 7 1 9 and 2 7 7 1 2, leaving the other rows all untouched. This changed the relative order of all the columns with a 9:

2 7 7 1 2  < - was third
3 1 8 1 9    < - so this row is now re-ordered!
2 1 7 1 9  < - was first
3 7 8 2 9

Sorting the above output by the 2nd column (7, 1, 1, 7) then leads to the wrong output you see.

A stable sort algorithm would have moved the 2 7 7 1 2 row to be the first row without reordering the other rows:

2 7 7 1 2  < - was third
2 1 7 1 9  < - was first
3 1 8 1 9  < - was second, stays *after* the first row
3 7 8 2 9  < - was third, stays *after* the second row

and sorting by the second column produces the correct output.

The default Python sort implementation, TimSort (named after its inventor, Tim Peters), is a stable sort function. You could just use that (via the list.sort() method and a sort key function):

def sort_matrix_columns(matrix, sort_columns):
    for col in sort_columns:
        matrix.sort(key=lambda row: row[col - 1])

Heads-up: I removed the n parameter from the function, for simplicity's sake.

Demo:

>>> def pm(m): print(*(' '.join(map(str, r)) for r in m), sep="\n")
...
>>> def sort_matrix_columns(matrix, sort_columns):
...     for col in sort_columns:
...         matrix.sort(key=lambda row: row[col - 1])
...
>>> sort_columns = [3, 1, 2, 4, 5, 2]
>>> matrix = [[3, 1, 8, 1, 9],
...           [3, 7, 8, 2, 9],
...           [2, 7, 7, 1, 2],
...           [2, 1, 7, 1, 9]]
>>> sort_matrix_columns(matrix, sort_columns)
>>> pm(matrix)
2 1 7 1 9
3 1 8 1 9
2 7 7 1 2
3 7 8 2 9

You don't need to use loop, if you reverse the sort_columns list and use that to create a single sort key, you can do this with a single call:

def sort_matrix_columns(matrix, sort_columns):
    matrix.sort(key=lambda r: [r[c - 1] for c in sort_columns[::-1]])

This works the same way, the most significant sort is the last column, only when two rows have the same value (a tie) would the one-but-last column sort matter, etc.