Sorting columns(comparison lexicography) in matrix | C - c

Question

I am stuck int he second part of this mission. I think i have problem with my algorithm.
Let me know please if my code is in the good direction.
This is my mession
Given set two - dimensional integers. The array consists of 5 rows and 10 columns. Each value in the system is a random number between 0 and 20. Have to write a program that performs the sorting of the array values as follows: First there arrange the values in each column so that they are sorted in ascending order (top to bottom), then - so there can sort the columns right "comes right" by comparing pairs of values in different columns in the same row (a "comparison lexicography"): comparing two values ​​in two columns in the first row, if they are the same compared to the values in the second row, and so on, and accordingly change the order of columns (see example in the third printing of the array, below). To display the array before sorting and after each of the two phases of the emergency. for example :
#include "stdio.h"
#include "conio.h"
#include "malloc.h"
#include "stdlib.h"
#define N 5
#define M 10
#define LOW 0
#define HIGH 20
void initRandomArray(int arr[N][M]);
void printArray(int arr[N][M]);
void SortInColumn(int arr[N][M],int m);
void SortColumns(int arr[][M]);
int compareColumns(int arr[][M], int col1, int col2);
void swapColumns( int col1, int col2);
int main()
{
int arr[N][M];
int m;
m=M;
srand((unsigned)time(NULL)); //To clear the stack of Random Number
initRandomArray(arr);
printf("Before sorting:\n");
printArray(arr);
printf("Sorting elements in each column:\n");
SortInColumn(arr,M);
printf("Sorting columns:\n");
SortColumns(arr);
system("pause");
return 0;
}
void initRandomArray(int arr[N][M])
{
int i,j;
for (i=0 ; i<N ; i++)
for (j=0 ; j<M ; j++)
{
arr[i][j]=LOW+rand()%(HIGH-LOW+1);
}
}
void printArray(int arr[N][M])
{
int i,j;
for (i=0 ; i<N ; i++)
{
for (j=0 ; j<M ; j++)
printf("%d ", arr[i][j]);
printf("\n");
}
}
void SortInColumn(int arr[][M],int m)
{
int i,j,k;
int temp;
for( k=0 ; k<m ; ++k) // loops around each columns
{
for(j=0; j<N-1; j++)// Loop for making sure we compare each column N-1 times since for each run we get one item in the right place
{
for(i=0; i < N-1 - j; i++) //loop do the adjacent comparison
{
if (arr[i][k]>arr[i+1][k]) // compare adjacent item
{
temp=arr[i][k];
arr[i][k]=arr[i+1][k];
arr[i+1][k]=temp;
}
}
}
}
printArray(arr);
}
void SortColumns(int arr[][M])
{ int row=0,cols=0,i=0,n=N;
int col1=arr[row][cols];
int col2=arr[row][cols];
compareColumns(arr,col1,col2);
}
int compareColumns(int arr[][M], int col1, int col2)
{
int row=0,cols=0,j;
for ( row=0 ; row < N ; row ++ );
{
for( cols=0 ; cols < M-1 ; cols++)
{
if(arr[row][cols]>arr[row][cols+1])
{
for (j=0 ; j < M-1 ; j++)
{
col1=arr[row][cols];
col2=arr[row][cols+1];
swapColumns(col1 , col2 );
}
}
}
}
printArray(arr);
}
void swapColumns(int col1, int col2)
{
int temp;
temp=col1;
col1=col2;
col2=temp;
}
By the way is the Complexity of compareColumns function is (n^3) ?

Answer 1

That algorithm is too slow, you can do better.
You can exploit the fact that every number is between 0 and 20 to sort the columns in linear time. To do so, use an auxiliary 20x10 array, where array[i][j] holds how many times the value i appears in column j of the original matrix. For your example, the first column holds the values 12, 18, 13, 17, 13, thus we would have:
array[12][0] = 1
array[13][0] = 2
array[18][0] = 1
array[17][0] = 1
Building this array takes O(n) time for a matrix with n elements (in fact, the problem size is always the same - 5*10 = 50)
Aftr building that array, you now have two possibilities:
a) Overwrite the original matrix with the sorted column values. For this, you would go into each column j in the auxiliary array, and scan the values. For the first column, for example, the first non-zero value is in array[12][0], which is 1, so you write "12" in the first column in the original array, and increment the row count so that you will write the next value in the correct position. Then, you'd see that array[13][0] is 2, so you'd write "13" twice in the original matrix. You keep doing this for every column. Now you have a matrix with sorted columns, and you can apply your method for lexicographic sorting between columns.
b) Since you want lexicographic order between columns, you can see that this is equivalent to sorting columns by their accumulated sum value. So, you could store another additional array of 10 elements, where each element is a structure holding the accumulated sum for array[0..20][j], and the position j (note that for position i, array[i][j]*i is the real value for the sum). Sorting this 10-element array is very fast, and now all you have to do is iterate through this sorted array. For each position in that array, you use the original index j (stored in the structure before) to index array[0][j], and then overwrite the original matrix using the method described in a). This has the advantage that you don't need to write any sorting procedure at all, you can use your system qsort.
This solution scales well for acceptable values. For a matrix with N elements, building the auxiliary array and the accumulated sums array takes O(N). Sorting the accumulated sums array takes time proportional to the number of columns, and overwriting the original array takes O(N) time.
Note that this algorithm is quick enough, but it can consume a lot of memory for very big values. You might want to think if you can reduce memory usage by increasing runtime.
As for the code you posted, it's very incomplete, please try to provide us with something a little more polished.