Sorting Multidimensiona l Array

[Index]

Hi, I have a 4 dimensional array and I want to sort it by the first two
columns emulating an ORDER BY clause to some extent.Any suggestion?

The original Array is:

Row1-> 4 8 2 9
Row2-> 4 5 5 3
Row3-> 3 9 8 7
Row4-> 8 2 4 8

The sorted array should look:

Row1-> 3 9 8 7
Row2-> 4 5 5 3
Row3-> 4 8 2 9
Row4-> 8 2 4 8

In fact the columns upon which the sorting is to be done is also
dynamic.
Please provide me some efficient algo or implementation. The data to be
handled is rather huge.So efficiency is a vital requirement.
Thanks.

[Ian Collins]

Index wrote:

Hi, I have a 4 dimensional array and I want to sort it by the first two
columns emulating an ORDER BY clause to some extent.Any suggestion?

The original Array is:

Row1-> 4 8 2 9
Row2-> 4 5 5 3
Row3-> 3 9 8 7
Row4-> 8 2 4 8

The sorted array should look:

Row1-> 3 9 8 7
Row2-> 4 5 5 3
Row3-> 4 8 2 9
Row4-> 8 2 4 8

In fact the columns upon which the sorting is to be done is also
dynamic.
Please provide me some efficient algo or implementation. The data to be
handled is rather huge.So efficiency is a vital requirement.

Store your data in a struct and define a < operator for the struct based
on your sort rules. Then shove the data structs into a set.

Something like:

struct Data
{
int a, b, c, d, e;

bool operator<( const Data& ) const;
};

bool Data::operator< ( const Data& data ) const
{
return (a < data.a) ? true : (a == data.a) ? data.b > b : false;
}

If you want greater efficiency, create a smart pointer type for Data
with its own < operator and put these in the set.

--
Ian Collins.

[Ian Collins]

Ian Collins wrote:

If you want greater efficiency, create a smart pointer type for Data
with its own < operator and put these in the set.

I should have added - be sure to profile both options and don't bother
with the second unless you realy have to!

--
Ian Collins.

[Roland Pibinger]

On 26 May 2006 17:45:46 -0700, "Index" <ka************ ****@gmail.com>
wrote:

Hi, I have a 4 dimensional array and I want to sort it by the first two
columns emulating an ORDER BY clause to some extent.Any suggestion?

The original Array is:

Row1-> 4 8 2 9
Row2-> 4 5 5 3
Row3-> 3 9 8 7
Row4-> 8 2 4 8

The sorted array should look:

Row1-> 3 9 8 7
Row2-> 4 5 5 3
Row3-> 4 8 2 9
Row4-> 8 2 4 8

In fact the columns upon which the sorting is to be done is also
dynamic.
Please provide me some efficient algo or implementation. The data to be
handled is rather huge.So efficiency is a vital requirement.
Thanks.

It's not possible to use qsort or std::sort directly because arrays
are not first class objects in C/C++. You should use a struct wrapper
for your Rows as vaguely indicated by Ian Collins.

Best wishes,
Roland Pibinger

[Ian Collins]

Roland Pibinger wrote:

It's not possible to use qsort or std::sort directly because arrays
are not first class objects in C/C++. You should use a struct wrapper
for your Rows as vaguely indicated by Ian Collins.

vaguely?

"Store your data in a struct and define a < operator for the struct
based on your sort rules."

I guess I could have shouted :)

--
Ian Collins.

[Phlip]

Ian Collins wrote:

Roland Pibinger wrote:

It's not possible to use qsort or std::sort directly because arrays
are not first class objects in C/C++. You should use a struct wrapper
for your Rows as vaguely indicated by Ian Collins.

vaguely?

Arrays are not first class objects?

template<class T, const size_t extent>
size_t
extent_of(T(&)[extent]) { return extent; }

RP meant that arrays are tricky to use as first class objects, and that
those sorters require a wrapper...

--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[Roland Pibinger]

On Sat, 27 May 2006 21:59:35 GMT, "Phlip" <ph******@yahoo .com> wrote:

Arrays are not first class objects?

template<class T, const size_t extent>
size_t extent_of(T(&)[extent]) { return extent; }

I don't know what you want to demonstrate. The original problem,
sorting a 2-dimensional array (preferably with Standard facilities
like sort or qsort), is still unresolved in the currend thread.

Best regards,
Roland Pibinger