Gelöst. Dramatischer Performanz-Verlust beim Sortieren!

namtel

Hallo,

nach einem Refactoring braucht der Sortieralgorithmus auf einmal
dreimal so lange wie vorher.

Der Aufruf ist vorher gewesen:

std::list< std::vector< double > > list = ...;
list->sort( SortList() );

Nach dem Refactoring gibt es eine eigene Container-Klasse:

std::list< Container > list = ...;
list->sort( SortList() );

Liegt das an der Sortierklasse?

Vorher:

enum MatrixCol
{
	FROM = 0, 
	TO = 1,
	COUNT = 2,
	RANGE = 3,
	MEAN = 4,
	COUNT_FULL = 5
};

class SortList
{
public:
	bool operator()( const std::vector<double> & x, const std::vector<double> & y )
	{
		if( x[MatrixCol::RANGE] == y[MatrixCol::RANGE] )
		{
			if( x[MatrixCol::MEAN] == y[MatrixCol::MEAN] )
			{
				if( x[MatrixCol::FROM] == y[MatrixCol::FROM] )
				{
					return x[MatrixCol::TO] < y[MatrixCol::TO];
				}
				return x[MatrixCol::FROM] < y[MatrixCol::FROM];
			}
			return x[MatrixCol::MEAN] > y[MatrixCol::MEAN];
		}
		return x[MatrixCol::RANGE] > y[MatrixCol::RANGE];
	}
};

Nachher:

class Container
{
public:
	int m_from, m_to, m_count;
	double m_range, m_mean;
};

class SortList
{
public:
	bool operator()( const Container & x, const Container & y )
	{
		if( x.m_range == y.m_range )
		{
			if( x.m_mean == y.m_mean )
			{
				if( x.m_from == y.m_from )
				{
					return x.m_to < y.m_to;
				}
				return x.m_from < y.m_from;
			}
			return x.m_mean < y.m_mean;
		}
		return x.m_range > y.m_range;
	}
};

Wie würde man das besser machen? Der Nachteil an der alten Variante ist,
dass from, to und count eben keine doubles, sondern integers sind.

Danke für Antworten!

namtel

Es lag nicht an der Sortierklasse, sondern an verkehrter Parameterübergabe an anderer Stelle im Programm.

So weit so gut!

Fellhuhn

Du sortierst auch anders, ist das gewollt?

namtel

Ich habe eine ganze Reihe von Sortierklassen und hab sie vereinfacht für die Forumfrage. Das sind also eigentlich zwei verschiedene.
Danke fürs aufmerksam hingucken!