C ++ MAP -Sortierung nach Schlüssel

Eine Karte besteht aus Schlüssel-/Wertpaaren. Jedes Paar ist ein Element. Alle Schlüssel in einer Karte sind einzigartig. Eine Karte kann nach Schlüssel sortiert werden. Die Sortierung kann aufsteigend oder absteigend sein. Aufsteigung ist der Standardwert. Das Sortieren in einer Karte ist nicht immer einfach. Es braucht ein Vergleichsfunktionsobjekt. Wenn das Vergleichsobjekt ignoriert wird, findet die Standardsortierung statt.

Wenn die Schlüsseln konstante Zeiger zu Charakter sind, wird die Karte von den Schlüsselzeiger sortiert und nicht von den wichtigsten Zeichenfolgenliteralen. Dies ist kaum das, was jemand will. Betrachten Sie die folgenden Schlüssel-/Wertpaare von Früchten und ihre äußeren Farben:

"Plum" => "lila"
"Blackberry" => "Dunkelblau-Black"
"Wassermelone" => "Grün"
"Aprikose", => "Orange"
"Papaya" => "Orange"
"Banane" => "Gelb"

Die Früchte sind die Schlüssel und die Farben sind die Werte. Diese Liste der Elemente (Schlüssel-/Wertpaare) ist nicht sortiert. Das folgende Programm erstellt eine Karte dieser Liste, wie sie ist, und zeigt sie so an, wie es ist, und von String -Literalen nicht

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Karte Abgeordneter;
MP ["Plum"] = "lila";
MP ["Blackberry"] = "Dark Blue-Black";
MP ["Watermelon"] = "Green";
MP ["apricot"] = "orange";
MP ["Papaya"] = "Orange";
MP ["Banane"] = "gelb";
für (Karte:: iterator it = mp.Start(); Es != MP.Ende(); es ++)
Cout << it->Erste << " => " << it->zweite << endl;
Rückkehr 0;

Die Ausgabe ist:

Plum => lila
Blackberry => Dunkelblau-Black
Wassermelone => grün
apricot => orange
Papaya => Orange
Banane => Gelb

von String -Literalen ungeortiert, aber von Zeigern sortiert. Um eine Karte in einem C ++ - Programm zu verwenden, muss die Kartenbibliothek in einer Richtlinie enthalten sein.

Eine andere Möglichkeit, die obige einfache Karte zu erstellen, ist wie folgt:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Karte MP ("Plum", "lila", "Blackberry", "Dark Blue-Black", "Watermelon", "Green", "Apricot", "Orange", "Papaya" , "Orange", "Banana", "Yellow");
für (Karte:: iterator it = mp.Start(); Es != MP.Ende(); es ++)
Cout << it->Erste << " => " << it->zweite << endl;
Rückkehr 0;

Die Ausgabe ist:

Plum => lila
Blackberry => Dunkelblau-Black
Wassermelone => grün
apricot => orange
Papaya => Orange
Banane => Gelb

von String -Literalen nicht absortiert, obwohl sie von Zeigern sortiert werden. Wenn die Schlüssel Ganzzahlen wären, wäre die Ausgabe nach Schlüssel sortiert worden. In der Praxis sind die Schlüssel vieler Karten String -Literale. In diesem Artikel wird erläutert, wie Tasten von String -Literalen eine Karte sortieren können.

Artikelinhalt

• Während der Schöpfung sortiert
• Erzeugen Sie eine Reichweite, die absteigend abfällt
• Vergleich von zwei Elementen nach Schlüssel
• Sortierung der mit Initializer -Liste erstellten Karte
• Abschluss

Sortieren Sie während der Schöpfung

Die vollständige Vorlage für die Kartenkonstruktion lautet:

Vorlage, Klassenallocator = Allocator>> Klassenkarte;

Die Klassen, vergleichen und Allocator, haben Standardwerte. Das heißt, sie haben eine Standardspezialisierung, die nicht in den Kartendeklarationen (Instanziationen) eingegeben werden muss. Was hier von Interesse ist, ist die Vergleichsklasse. Der Name der Klasse wird verglichen, und die Standardspezialisierung ist „weniger“. "weniger

Eine Karte wird normalerweise erstellt, die während der Erstellung von Schlüssel sortiert werden. Wenn die Schlüssel const char*sind, werden die Zeiger auf die zitierten wörtlichen Saiten sortiert, nicht die wörtlichen Texte. Um Saiten als Tasten zu haben, die während der Erstellung sortiert sind, müssen die Saiten Literale von String -Objekten sein, die aus der String -Klasse instanziiert sind. Dies bedeutet, dass die String -Bibliothek sowie die Kartenbibliothek enthalten sein muss.

Erstellen aufsteigend

Im folgenden Programm wird die Karte erstellt, sortiert aufgestiegen:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Karte> MP;
MP ["Plum"] = "lila";
MP ["Blackberry"] = "Dark Blue-Black";
MP ["Watermelon"] = "Green";
MP ["apricot"] = "orange";
MP ["Papaya"] = "Orange";
MP ["Banane"] = "gelb";
für (Karte:: iterator it = mp.Start(); Es != MP.Ende(); es ++)
Cout << it->Erste << " => " << it->zweite << endl;
Rückkehr 0;

Die Ausgabe ist:

apricot => orange
Banane => Gelb
Blackberry => Dunkelblau-Black
Papaya => Orange
Plum => lila
Wassermelone => grün

Selbst wenn weniger in der Vorlage weggelassen worden wäre, wäre die Sortierung immer noch aufgestiegen, da weniger der Standard ist.

Abstieg erstellen

Um eine Karte zu erstellen, so dass sie in absteigender Reihenfolge nach Schlüssel sortiert ist, muss die Vergleichspezialisierung codiert werden. Das folgende Programm zeigt dies:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Karte> MP;
MP ["Plum"] = "lila";
MP ["Blackberry"] = "Dark Blue-Black";
MP ["Watermelon"] = "Green";
MP ["apricot"] = "orange";
MP ["Papaya"] = "Orange";
MP ["Banane"] = "gelb";
für (Karte:: iterator it = mp.Start(); Es != MP.Ende(); es ++)
Cout << it->Erste << " => " << it->zweite << endl;
Rückkehr 0;

Die Ausgabe ist:

Wassermelone => grün
Plum => lila
Papaya => Orange
Blackberry => Dunkelblau-Black
Banane => Gelb
apricot => orange

Erzeugen Sie eine Reichweite, die absteigend abfällt

Ein Bereich einer Karte kann in absteigender Reihenfolge erzeugt werden. Dies beinhaltet das Erstellen einer zweiten Karte, die eine Reichweite der ersten Karte enthält. Das folgende Programm zeigt dies:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Karte Abgeordneter;
MP ["Plum"] = "lila";
MP ["Blackberry"] = "Dark Blue-Black";
MP ["Watermelon"] = "Green";
MP ["apricot"] = "orange";
MP ["Papaya"] = "Orange";
MP ["Banane"] = "gelb";
Karte:: iterator itb = mp.Start();
ITB ++;
Karte:: iterator ite = mp.Ende();
ite--;
Karte> mpr (itb, ite);
für (Karte:: iterator it = mpr.Start(); Es != Mpr.Ende(); es ++)
Cout << it->Erste << " => " << it->zweite << endl;
Rückkehr 0;

Die Ausgabe ist:

Plum => lila
Papaya => Orange
Blackberry => Dunkelblau-Black
Banane => Gelb

Das erste Kartenobjekt enthält sechs Elemente, die sind:

apricot => orange
Banane => Gelb
Blackberry => Dunkelblau-Black
Papaya => Orange
Plum => lila
Wassermelone => grün

Der in Betracht gezogene Bereich ist:

Banane => Gelb
Blackberry => Dunkelblau-Black
Papaya => Orange
Plum => lila
Wassermelone => grün

Im Code zeigt "ITB ++" auf "Banana", "Gelb" und "ITE-" auf "Watermelon", "Green" für den Bereich. Bei der Behandlung eines Bereichs in C ++ ist das endgültige Element nicht an der Manipulation beteiligt. Und so hat die Ausgabe vier Elemente mit "Wassermelone", "grün" weggelassen.

Die Spezialisierung des Parameters der Vergleichsvorlagen der zweiten Karte ist größer. Wenn es weniger oder weggelassen wäre, hätte der Bereich zu Aufstiegsordnung geführt.

Vergleich von zwei Elementen nach Schlüssel

KEY_COMPARE KEY_COMP () const

Diese Mitgliedsfunktion gibt eine Kopie des vom Kartencontainer verwendeten Vergleichsobjekts zurück, um Schlüssel zu vergleichen. Ein Vergleichsobjekt ist ein Funktionsobjekt. Es würde zwei Schlüssel als Argumente benötigen und true zurückkehren, wenn die linke Taste weniger als rechts ist. Damit sollte das Codesegment sein:

KEY_COMPare KC = MP.Key_Comp ();
bool BL = KC ("Wassermelone", "Aprikose");

Key_Compare wird vom Compiler nicht erkannt. Die Eliminierung von Key_Compare in diesem Codesegment durch Ersetzen von KC in der zweiten Anweisung ergibt:

bool BL = MP.key_comp () ("watermelon", "apricot");

Das folgende Programm zeigt die Verwendung von Key_Comp ().

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Karte Abgeordneter;
MP ["Plum"] = "lila";
MP ["Blackberry"] = "Dark Blue-Black";
MP ["Watermelon"] = "Green";
MP ["apricot"] = "orange";
MP ["Papaya"] = "Orange";
MP ["Banane"] = "gelb";
bool BL = MP.key_comp () ("watermelon", "apricot");
Cout << bl << endl;
Rückkehr 0;

Die Ausgabe ist 0 für false.

Das eigentliche Problem mit dem obigen Codesegment ist, dass der Namespace für Key_Compare nicht gut ausgedrückt wurde. Wenn das Segment wäre,

Karte:: KEY_COMPARE KC = MP.Key_Comp ();
bool BL = KC ("Wassermelone", "Aprikose");

Es hätte funktioniert (vom Compiler akzeptiert).

value_compare value_comp () const

Diese Mitgliedsfunktion ist ähnlich wie bei Key_Comp (). HINWEIS: Hier ist es nicht der Wert des Schlüssel-/Wertpaares, auf das erwähnt wird. Es ist das Element des Schlüssel-/Wertpaares. Die beiden Argumente für das Funktionsobjekt Value_Compare sind Iteratorelemente. Das folgende Programm verwendet Value_Comp (), um die ersten und letzten Elemente zu vergleichen, "Apricot", "Orange" und "Watermelon", "Green":

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Karte> MP;
MP ["Plum"] = "lila";
MP ["Blackberry"] = "Dark Blue-Black";
MP ["Watermelon"] = "Green";
MP ["apricot"] = "orange";
MP ["Papaya"] = "Orange";
MP ["Banane"] = "gelb";
Karte:: iterator itb = mp.Start();
Karte:: iterator ite = mp.Ende();
ite--;
Karte:: value_compare vc = mp.value_comp ();
bool bl = vc ( *itb, *ite);
Cout << bl << endl;
Rückkehr 0;

Die Ausgabe ist 1 für wahr. Die Iteratoren ITB und ITE waren mit dem Indirektion Operator die Elemente mit ihren Elementen auf.

Sortierung der mit Initializer -Liste erstellten Karte

Im folgenden Programm, bei dem die Sortierung abfällt, sind die Tasten String -Objekte, die aus der String -Klasse instanziiert wurden:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Karte> mp ("Plum", "lila", "Blackberry", "Dark Blue-Black", "Watermelon", "Green", "Apricot", "Orange", "Papaya "," orange ", " banana "," gelb ");
für (Karte:: iterator it = mp.Start(); Es != MP.Ende(); es ++)
Cout << it->Erste << " => " << it->zweite << endl;
Rückkehr 0;

Die Ausgabe ist:

Wassermelone => grün
Plum => lila
Papaya => Orange
Blackberry => Dunkelblau-Black
Banane => Gelb
apricot => orange

Abschluss

Eine Karte wird erstellt, sortiert nach Schlüssel und aufsteigend. Aufsteigung ist die Standardreihenfolge. Fügen Sie die Vorlagenparameterspezialisierung als drittes Argument in die Vorlagenargumentliste hinzu, damit die Vorlagenparameterspezialisierung größer ist. HINWEIS: Wenn es sich bei den Schlüsseln um Saiten handelt, müssen sie aus der String -Klasse instanziiert werden, wie oben dargestellt. Stringschlüssel als const-char* oder char-arr [] enden mit ihren Zeigern sortiert und nicht mit ihren Literalen.