Ich versuche mich gerade an Kruskals Algorithmus um ein Netzwerkproblem zu lösen.

Meine Frage: Wie kann ich einen Vektor sortieren?
Und zwar ist es ein Vektor folgender Form " vector<Edge*> " wobei jede Kante edge (welche im Vektor ist) ein Gewicht hat, also edge-> weight.
Nun möchte ich meinen Vektor so sortieren, dass die Kante mit kleinstem Gewicht zuerst steht, etc.

Ich habe mal gegoogelt und habe etwas in der Art sort(vector.begin(), vector.end(),function comp) gefunden...ich verstehe aber nicht ganz wie ich das umsetzen kann. Könnte mir jemand erklären wie das funktioniert und wie ich meinen Vektor sortieren kann?

lieber Gruss & schon mal vielen Dank

Bist du sicher, dass du einen vector benutzen möchtest und keinen Container, der automatisch ständig sortiert ist, wie z.B. (multi-)set? Edge klingt nach Grafikkram, da kenne ich mich nicht so aus, kann sein, dass ich Mist erzähle mit dem set und man das bei Computergrafik nicht so macht.

So kannst du das machen:

#include <algorithm>
#include <iostream>
#include <vector>

using std::cout;
using std::cin;
using std::endl;
using std::vector;

struct Edge
{
	// Other stuff
	double distance;

	Edge( double dist )
		: distance(dist)
	{}
};

// Compares two Edges by their distance
bool compare( const Edge& e1, const Edge& e2 )
{
	return e1.distance < e2.distance;
}

int main()
{
	vector<Edge> edges;
	edges.push_back( Edge(2.3) );
	edges.push_back( Edge(0.3) );
	edges.push_back( Edge(1.0) );

	cout << "Unordered:" << endl;
	for ( size_t i = 0; i < edges.size(); ++i )
		cout << edges[i].distance << endl;

	std::sort( edges.begin(), edges.end(), compare );

	cout << endl << "Ordered:" << endl;
	for ( size_t i = 0; i < edges.size(); ++i )
		cout << edges[i].distance << endl;
}

Falls du etwas im Code nicht verstehst frage einfach nach

Bist du sicher, dass du einen vector benutzen möchtest und keinen Container, der automatisch ständig sortiert ist, wie z.B. (multi-)set?

Ergänzend zu SeppJ möchte ich heap einwerfen.

Ergänzend zu SeppJ möchte ich heap einwerfen.

Ich staune gerade, dass die Seite von einer Uni sein soll. Bin ich so neben der Rolle? Zuerst einmal ist der Algorithmus falsch formuliert. Man kann nicht einfach billigste Kanten in den Wald einfügen, bis er zusammenhängend ist. Dabei können Kreise entstehen, sodass das Ergebnis kein Baum ist. Dann sehe ich nicht, warum man alle Kanten in einem Heap vorhalten sollte. Ein sortiertes Array tuts ebenfalls. Die Laufzeit des Algorithmus wird mit dem Heap erklärt, aber auf die Laufzeit zum Vereinigen der Zusammenhangskomponenten im Wald geht er nicht ein. Der unten stehende Satz gilt nur, wenn alle Kantengewichte paarweise verschieden sind.

Edit: Auf der nächsten Seite wirds nicht besser. Da wird als Laufzeit von Prim O(m*log(n)) angegeben, was bei dichten Graphen schneller sein soll, weil bei Prim die Laufzeit m*log(m) = n²*log(n)*2 sei. Von Landaunotation hat der Herr wohl noch nichts gehört. Lustigerweise schreibt er zwei Sätze vorher, dass bei Prim jede Kante zweimal bearbeitet wird. Wo ist dieser Faktor 2 denn jetzt hin? Sowas war mal ne Vorlesung?

Edit: Und bei negativen Kantenkosten ist das Kürzeste-Wege-Problem nicht wohldefiniert. Soso, auf konservativen Gewichten gibts also kein Bellman-Ford?

volkard schrieb:

Ergänzend zu SeppJ möchte ich heap einwerfen.

Ich staune gerade, dass die Seite von eine Uni sein soll...

Ich muß gestehen, daß von der einfachen Heuristik "Graphentheorie => Heap" ausging. Die klappt verdammt oft. Einfach mal gegoogelt. Und dann habe ich einfach geglaubt, weil die Seite von einer Uni ist. Nein, habe ich nicht. Es paßte nicht. Der Algo forderte keinen Heap. Da war ich verwirrt. Und dann habe ich nachgedacht. Aber alles, was ich dachte, war widersprüchlich zur Uni-Seite. Nuja, Uni hat recht, dachte ich dann. Sorry.