Als ich mir heute einen Codeabschnitt ansah, stellte ich fest, dass die Sortierung in nur einem Satz erfolgte, der wie folgt aussieht:

sort (rotateArray.begin(),rotateArray.end( ));

Ich war schockiert.

Verwendung der Sortierfunktion

Schreiben Sie Ihre eigene O(n^2)-Sortierung Wie eine Blase, die nicht nur einfach zu programmieren ist. Wenn das Zeitlimit überschritten wird, ist es sehr wahrscheinlich, dass sie falsch geschrieben wird.

In STL gibt es eine Sortierfunktion, die das Array direkt sortieren kann, mit einer Komplexit?t von n*log2(n). Um diese Funktion nutzen zu k?nnen, müssen Sie die Header-Datei einbinden.
Diese Funktion kann zwei Parameter oder drei Parameter übergeben. Der erste Parameter ist die erste Adresse des zu sortierenden Intervalls und der zweite Parameter ist die n?chste Adresse der Endadresse des Intervalls.

Mit anderen Worten, das Sortierintervall ist [a,b). Einfach ausgedrückt gibt es ein Array int a[100]. Um die Elemente von a[0] bis a[99] zu sortieren, schreiben Sie einfach sort(a, a 100). Die Standardsortiermethode ist aufsteigend.
Nehmen Sie die Frage ?AC-Strategie“, die ich gestellt habe, als Beispiel. Wenn Sie die Elemente von 0 bis len-1 des Arrays t sortieren müssen, schreiben Sie einfach sort(t,t len); vector v auch. Fast, sort(v.begin(),v.end());//Das ist genau die Verwendung, die ich zuvor gesehen habe
Der Datentyp der Sortierung ist nicht auf Ganzzahlen beschr?nkt, solange die Typ, der die Kleiner-als-Operation definiert, kann sein, z. B. Zeichenfolgenklasse Zeichenfolge.
Wenn für die Kleiner-als-Operation kein Datentyp definiert ist oder Sie die Sortierreihenfolge ?ndern m?chten, müssen Sie den dritten Parameter verwenden – die Vergleichsfunktion. Die Vergleichsfunktion ist eine selbstdefinierte Funktion und der Rückgabewert ist vom Typ Bool. Er gibt an, welche Art von Beziehung ?kleiner als“ ist. Wenn Sie das Integer-Array gerade in absteigender Reihenfolge sortieren m?chten, k?nnen Sie zun?chst eine Vergleichsfunktion cmp
bool cmp(int a,int b)
{
return a>b;
} definieren.
sorted Dann schreiben Sie sort(a,a 100,cmp);

Angenommen, Sie definieren einen Strukturknoten

struct node{
int a;
int b;
double c ;
}
Es gibt einen Array-Knoten arr[100] vom Knotentyp. Ich m?chte ihn zuerst nach dem a-Wert in aufsteigender Reihenfolge sortieren. Wenn der a-Wert derselbe ist, dann sortiere ihn nach dem b-Wert in absteigender Reihenfolge. Wenn b immer noch derselbe ist, sortieren Sie einfach in absteigender Reihenfolge nach c.

Sie k?nnen eine solche Vergleichsfunktion schreiben:

Das Folgende ist der Codeausschnitt:

bool cmp(node x,node y)
{
     if(x.a!=y.a) return x.a
     if(x.b!=y.b) return x.b>y.b;
     return return x.c>y.c;

}

Schreiben Sie beim Sortieren sort(arr,a 100,cmp);

qsort(s[0],n,sizeof(s[0]),cmp);

int cmp(const void *a,const void *b)
{
return *(int *)a-*(int *)b;
}

1. Int-Typ-Array sortieren

int num[100]; >

Beispiel:

int cmp ( const void *a , const void *b )

{

return *(int *)a - *(int *)b
}

qsort(num,100,sizeof(num[0]),cmp);

2. Char-Typ-Array sortieren (wie int-Typ)

char-Wort [100 ];

Beispiel:

int cmp( const void *a, const void *b)

{

return *(char *)a - *(int * )b ;
}

qsort(word,100,sizeof(word[0]),cmp>3. Sortieren Sie Arrays vom Typ Double (achten Sie besonders darauf)

double in[100];

int cmp( const void *a, const void *b)

{

return *(double *)a > *(double *)b ? 1 : -1;

}

qsort(in,100,sizeof(in]),cmp

4 ?? >struct In

{

double data;

}s[100]

// Sortieren Sie die Strukturen nach dem Wert der Daten von klein nach gro?. Bezüglich der Sortierung von Schlüsseldaten gibt es viele Arten von Daten. Sehen Sie sich das obige Beispiel an und schreiben Sie

int cmp( const void *a, const void *b)
{
return ((In *)a)- >data - ((In *)b)->data ;

qsort(s,100,sizeof(s[0]),cmp); ??>5. Richtige Struktur

struct In

{
int x;
}s[100]; klein nach gro?, wenn x gleich ist, sortiere y von gro? nach klein

int cmp( const void *a, const void *b)

{

struct In *c = (In *) a;

struct In *d = (In *)b;

if(c->x != d->x) return c->x - d->x >y - c ->y;

qsort(s,100,sizeof(s[0]),cmp>6 > struct In
{
int data;
char str[100]; die Struktur

int cmp ( const void *a , const void *b )

{

return strcmp( ((In *)a)->str , ((In *)b)- >str ) ;
}

qsort(s,100,sizeof(s[0]),cmp);

7. Cmp zum Finden einer konvexen Hülle in der Computergeometrie

int cmp(const void *a,const void *b) //Die Schlüsselfunktion cmp besteht darin, alle Punkte au?er 1 Punkt nach Drehwinkel zu sortieren
{
struct point *c=(point *)a
struct point *d=(point *)b; 0) return 1;
else if( !calc(*c,*d,p[1]) && dis(c->x,c->y,p[1].x,p[1] . y) < 0) return 1;
x,d->y,p[1].x,p[1].y)) //Wenn es auf einer geraden Linie liegt, setze das andere vor < dis(d->return 1; ??>else return -1;
}

Okay, nachdem wir über so viele Verwendungsm?glichkeiten gesprochen haben, ist irgendjemand immer noch verwirrt darüber, was STL ist?

Lassen Sie uns darüber sprechen, was STL (Content Source Network) ist, eine effiziente C-Bibliothek. Es ist in der C-Standardbibliothek enthalten und der neueste und revolution?rste Teil des ANSI/ISO-C-Standards. Diese Bibliothek enth?lt viele grundlegende Datenstrukturen und grundlegende Algorithmen, die h?ufig in der Informatik verwendet werden. Es bietet ein erweiterbares Anwendungsframework für C-Programmierer, das die Wiederverwendbarkeit von Software in hohem Ma?e widerspiegelt.

Auf logischer Ebene verk?rpert STL die Idee der generischen Programmierung und führt viele neue Begriffe ein, wie z. B. Anforderungen, Konzepte, Modelle (Modell), Container (Container), Algorithmus (Algorithmus), Iterator (Iterator). ), usw. Wie Polymorphismus in OOP (objektorientierte Programmierung) sind auch Generika eine Software-Wiederverwendungstechnologie

Auf der Implementierungsebene wird die gesamte STL mit einem Typ (typparametrisiert) parametrisiert, der auf einer Sprachfunktion basiert das war in der früheren C-Standardvorlage nicht enthalten. Wenn Sie den Quellcode einer beliebigen STL-Version überprüfen, werden Sie feststellen, dass es absolut wahr ist, dass Vorlagen als Eckpfeiler der gesamten STL dienen. Darüber hinaus gibt es viele neue Funktionen von C, die die Implementierung von STL erleichtern.

2. Die sechs Hauptkomponenten von STL

Container sind eine Datenstruktur. wie list, vector und deques, bereitgestellt als Methode einer Vorlagenklasse. Um auf die Daten im Container zuzugreifen, k?nnen Sie die Iterator-Ausgabe der Container-Klasse verwenden.

Iterator (Iterator) stellt Methoden für den Zugriff auf Objekte im Container bereit. Sie k?nnen beispielsweise ein Iteratorpaar verwenden, um einen Bereich von Objekten in einer Liste oder einem Vektor anzugeben. Ein Iterator ist wie ein Zeiger. Tats?chlich sind C-Zeiger auch Iteratoren. Iteratoren k?nnen jedoch auch Klassenobjekte sein, die ?operator*()“ und andere zeiger?hnliche Operatormethoden definieren.

Algorithmus ist eine Vorlagenfunktion, die zum Bearbeiten von Daten in einem Container verwendet wird. STL verwendet beispielsweise sort() zum Sortieren von Daten in einem Vektor und find() zum Suchen nach Objekten in einer Liste. Die Funktionen selbst haben nichts mit der Struktur und dem Typ der Daten zu tun, mit denen sie arbeiten, und k?nnen daher verwendet werden Von einfachen Arrays bis hin zu hochkomplexen Containerdatenstrukturen

Funktionsobjekt, Funktor wird auch als Funktionsobjekt bezeichnet, bei dem es sich tats?chlich um eine Struktur mit einem überladenen () Operator handelt. Es gibt nichts Besonderes

Iterationsadapter (Adaptor)

Speicherplatzzuweiser (Allokator) Die Hauptarbeit umfasst zwei Teile: 1. Erstellung und Zerst?rung von Objekten 2. Erwerb und Freigabe von Speicher

Die folgenden Hauptdiskussionen: Container , Iteratoren, Algorithmen, Adapter. Weitere Informationen finden Sie unter C Primer

1. STL-Container

1) Sequenzsequenzcontainer, jedes Element hat eine feste Position – es h?ngt von der Einfügezeit und -position ab, unabh?ngig vom Elementwert, Vektor, Deque, Liste Elemente k?nnen sehr schnell am Ende des Arrays hinzugefügt oder daraus entfernt werden. Es ist jedoch zeitaufw?ndiger, Elemente in der Mitte oder im Kopf zu platzieren.

Deques: ist die Abkürzung für ?Double-Ended Queue“, die zuf?llig auf Elemente zugreifen kann (direkter Zugriff über Indizes), Hinzufügen oder Bewegen Sie den Kopf und das Ende des Arrays. Alle Elemente werden sehr schnell entfernt. Es ist jedoch zeitaufw?ndiger, Elemente in der Mitte oder im Kopf einzufügen )), das Einfügen an jeder Position oder das L?schen geht sehr schnell, passen Sie einfach den Zeiger intern an

2) Zugeordnete Container (Zugeordnete Container), die Position der Elemente h?ngt von bestimmten Sortierkriterien ab und hat nichts damit zu tun mit der Einfügereihenfolge, Set, Multiset, Map, Multimap;

Sets/Multisets: Die internen Elemente werden automatisch nach ihren Werten sortiert. Ein Set kann nur einmal vorkommen Mehrere Elemente mit demselben Wert werden durch einen Bin?rbaum (eigentlich basierend auf dem Rot-Schwarz-Baum (RB-Baum)) implementiert, der leicht zu finden ist

Maps/Multimaps：Map的元素是成對的鍵值/實值，內(nèi)部的元素依據(jù)其值自動排序，Map內(nèi)的相同數(shù)值的元素只能出現(xiàn)一次，Multimaps內(nèi)可包含多個數(shù)值相同的元素，內(nèi)部由二叉樹實現(xiàn)（實際上基于紅黑樹(RB-tree）實現(xiàn)），便于查找；

另外有其他容器hash_map,hash_set,hash_multiset,hash_multimap。

容器的比較：

2.STL迭代器

Iterator（迭代器）模式又稱Cursor（游標）模式，用于提供一種方法順序訪問一個聚合對象中各個元素,
而又不需暴露該對象的內(nèi)部表示?；蛘哌@樣說可能更容易理解：Iterator模式是運用于聚合對象的一種模式，通過運用該模式，使得我們可以在不知道對象內(nèi)部表示的情況下，按照一定順序（由iterator提供的方法）訪問聚合對象中的各個元素。

迭代器的作用：能夠讓迭代器與算法不干擾的相互發(fā)展，最后又能無間隙的粘合起來，重載了*，＋＋，＝＝，?。?，＝運算符。用以操作復雜的數(shù)據(jù)結(jié)構(gòu)，容器提供迭代器，算法使用迭代器；

常見的一些迭代器類型：iterator、const_iterator、reverse_iterator和const_reverse_iterator

迭代器一般聲明使用示例

vector<T>::iterator it;
list<T>::iterator it;
deque<T>::iterator it；

input output

\ /

forward

|

bidirectional

|

random access

要注意，上面這圖表并不是表明它們之間的繼承關系：而只是描述了迭代器的種類和接口。處于圖表下層的迭代器都是相對于處于圖表上層迭代器的擴張集。例如：forward迭代器不但擁有input和output迭代器的所有功能，還擁有更多的功能。

各個迭代器的功能如下：

迭代器的操作：

每種迭代器均可進行包括表中前一種迭代器可進行的操作。

只有順序容器和關聯(lián)容器支持迭代器遍歷，各容器支持的迭代器的類別如下：

3.STL算法

STL算法部分主要由頭文件,,組成。要使用 STL中的算法函數(shù)必須包含頭文件，對于數(shù)值算法須包含，中則定義了一些模板類，用來聲明函數(shù)對象。
STL中算法大致分為四類：
1）、非可變序列算法：指不直接修改其所操作的容器內(nèi)容的算法。
2）、可變序列算法：指可以修改它們所操作的容器內(nèi)容的算法。
3）、排序算法：包括對序列進行排序和合并的算法、搜索算法以及有序序列上的集合操作。
4）、數(shù)值算法：對容器內(nèi)容進行數(shù)值計算。

Alle Algorithmen werden im Folgenden detailliert klassifiziert und ihre Funktionen sind gekennzeichnet:
<一>Suchalgorithmen (13): Bestimmen, ob der Container einen bestimmten Wert enth?lt
angrenzend_find: Innerhalb des Bereichs des Iteratorpaars, das Elemente identifiziert , find a. Wenn benachbarte doppelte Elemente gefunden werden, wird ein ForwardIterator zurückgegeben, der auf das erste Element des Elementpaars zeigt. Andernfalls kehren Sie zuletzt zurück. Die überladene Version verwendet den bin?ren Eingabeoperator, anstatt auf Gleichheit zu prüfen.
bin?re_Suche: Suchen Sie nach einem Wert in einer geordneten Sequenz und geben Sie ?true“ zurück, wenn er gefunden wird. Die überladene Version verwendet das angegebene Vergleichsfunktionsobjekt oder den Funktionszeiger, um die Gleichheit zu bestimmen.
Anzahl: Verwenden Sie den Gleichheitsoperator, um die Elemente im Flag-Bereich mit dem Eingabewert zu vergleichen und die Anzahl gleicher Elemente zurückzugeben.
count_if: Verwenden Sie den Eingabeoperator, um die Elemente innerhalb des Flag-Bereichs zu bearbeiten und die Anzahl der wahren Ergebnisse zurückzugeben.
equal_range: Die Funktion ?hnelt equal und gibt ein Iteratorpaar zurück, wobei der erste die untere Grenze und der zweite die obere Grenze darstellt.
finden: Verwenden Sie den Gleichheitsoperator des zugrunde liegenden Elements, um die Elemente im angegebenen Bereich mit dem Eingabewert zu vergleichen. Wenn eine übereinstimmung auftritt, wird die Suche beendet und ein InputIterator für das Element zurückgegeben.
find_end: Suchen Sie das letzte Vorkommen von ?der zweiten Sequenz, die durch ein anderes Paar von Eingabeiteratoren markiert ist“ im angegebenen Bereich. Wenn gefunden, wird der erste ForwardIterator des letzten Paars zurückgegeben, andernfalls wird der erste ForwardIterator der Eingabe ?anderes Paar“ zurückgegeben. Die überladene Version verwendet den vom Benutzer eingegebenen Operator anstelle der Gleichheitsoperation.
find_first_of: Suchen Sie das erste Vorkommen eines beliebigen Elements in der ?zweiten Sequenz, die durch ein anderes Paar von Eingabeiteratoren markiert ist“ innerhalb des angegebenen Bereichs. Die überladene Version verwendet benutzerdefinierte Operatoren.
find_if: Verwenden Sie die Eingabefunktion anstelle des Gleichheitsoperators, um find auszuführen.
Lower_bound: Gibt einen ForwardIterator zurück, der auf die erste Position innerhalb des geordneten Sequenzbereichs zeigt, an der der angegebene Wert eingefügt werden kann, ohne die Reihenfolge des Containers zu zerst?ren. überladene Funktionen verwenden benutzerdefinierte Vergleichsoperationen.
Upper_bound: Gibt einen ForwardIterator zurück, der auf die letzte Position zeigt, an der der Wert in den geordneten Sequenzbereich eingefügt wird, ohne die Containerreihenfolge zu zerst?ren. Diese Position markiert einen Wert, der gr??er als der Wert ist. überladene Funktionen verwenden benutzerdefinierte Vergleichsoperationen.
Suche: Bei zwei Bereichen wird ein ForwardIterator zurückgegeben. Wenn die Suche erfolgreich ist, zeigt er auf die Position, an der die Teilsequenz (zweiter Bereich) zum ersten Mal im ersten Bereich erscheint. Wenn die Suche fehlschl?gt, zeigt er auf last1 . Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
Search_n: Suche nach Teilsequenzen, in denen val innerhalb des angegebenen Bereichs n-mal vorkommt. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.

<二> Sortier- und allgemeine Algorithmen (14): Bereitstellung einer Elementsortierstrategie
inplace_merge: Zwei geordnete Sequenzen zusammenführen, und die resultierende Sequenz deckt beide Enden des Bereichs ab. Die überladene Version wird mithilfe der Eingabeoperation sortiert.
Merge: Zwei geordnete Sequenzen zusammenführen und in einer anderen Sequenz speichern. Die überladene Version verwendet einen benutzerdefinierten Vergleich.
n-tes_Element: Ordnen Sie die Reihenfolge im Bereich neu an, sodass alle Elemente, die kleiner als das n-te Element sind, davor und alle Elemente, die gr??er als das n-te Element sind, hinten erscheinen. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
Partial_sort: Sortiert die Sequenz teilweise, sodass die Anzahl der sortierten Elemente innerhalb des Bereichs platziert werden kann. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
Partial_sort_copy: ?hnlich wie Partial_sort, kopiert jedoch die sortierte Sequenz in einen anderen Container.
Partition: Ordnen Sie die Elemente im angegebenen Bereich neu an, verwenden Sie die Eingabefunktion und platzieren Sie die Elemente mit einem wahren Ergebnis vor den Elementen mit einem falschen Ergebnis.
Random_shuffle: Passt die Reihenfolge der Elemente im angegebenen Bereich zuf?llig an. Die überladene Version gibt einen Zufallszahlengenerierungsvorgang ein.
umkehren: Ordnen Sie die Elemente im angegebenen Bereich in umgekehrter Reihenfolge neu an.
reverse_copy: ?hnlich wie reverse, schreibt das Ergebnis jedoch in einen anderen Container.
Drehen: Verschieben Sie die Elemente im angegebenen Bereich an das Ende des Containers, und das Element, auf das die Mitte zeigt, wird zum ersten Element des Containers.
rotate_copy: ?hnlich wie rotieren, schreibt das Ergebnis jedoch in einen anderen Container.
Sortieren: Ordnen Sie die Elemente im angegebenen Bereich in aufsteigender Reihenfolge neu an. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
Stable_sort: ?hnlich wie sort, beh?lt jedoch die Reihenfolgebeziehung zwischen gleichen Elementen bei.
stabile_Partition: ?hnlich wie Partition, aber die relative Reihenfolge im Container bleibt nicht garantiert erhalten.

<三>L?sch- und Ersetzungsalgorithmen (15)
copy: Kopiersequenz
copy_backward: Wie copy, aber die Elemente werden in umgekehrter Reihenfolge kopiert.
iter_swap: Tauschen Sie die Werte zweier ForwardIterators aus.
entfernen: Alle Elemente im angegebenen Bereich entfernen, die dem angegebenen Element entsprechen. Beachten Sie, dass es sich bei dieser Funktion nicht um eine echte L?schfunktion handelt. Integrierte Funktionen sind nicht für die Verwendung mit den Funktionen ?remove“ und ?remove_if“ geeignet.
Remove_Copy: Kopiert alle nicht übereinstimmenden Elemente in einen angegebenen Container und gibt einen OutputIterator zurück, der auf die n?chste Position des zuletzt kopierten Elements zeigt.
Remove_if: Entfernt alle Elemente innerhalb des angegebenen Bereichs, deren Eingabeoperationsergebnis wahr ist.
remove_copy_if: Kopiert alle nicht übereinstimmenden Elemente in einen angegebenen Container.
ersetzen: Ersetzen Sie alle Elemente, die im angegebenen Bereich gleich vold sind, durch vnew.
replace_copy: ?hnlich wie replace, schreibt das Ergebnis jedoch in einen anderen Container.
replace_if: Ersetzen Sie alle Elemente mit echten Operationsergebnissen im angegebenen Bereich durch neue Werte.
replace_copy_if: Identisch mit replace_if, aber schreibt das Ergebnis in einen anderen Container.
Swap: Tauschen Sie die in zwei Objekten gespeicherten Werte aus.
swap_range: Tauscht die Elemente im angegebenen Bereich mit einem anderen Sequenzelementwert aus.
eindeutig: Doppelte Elemente aus der Sequenz entfernen. ?hnlich wie beim Entfernen k?nnen keine Elemente gel?scht werden. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
unique_copy: ?hnlich wie unique, gibt die Ergebnisse jedoch in einen anderen Container aus.

<四> Anordnungskombinationsalgorithmus (2): Stellen Sie alle m?glichen Anordnungen für den gegebenen Satz in einer bestimmten Reihenfolge bereit.
N?chste_Permutation: Nehmen Sie die Anordnung im aktuellen Bereich heraus und sortieren Sie sie zur n?chsten Anordnung neu. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
prev_permutation: Nehmen Sie die Sequenz im angegebenen Bereich heraus und ordnen Sie sie zur vorherigen Sequenz neu an. Gibt false zurück, wenn keine vorherige Sequenz vorhanden ist. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.

<五>Arithmetischer Algorithmus (4)
akkumulieren: Die Summe der vom Iterator identifizierten Sequenzsegmentelemente wird zu einem durch val angegebenen Anfangswert addiert. Die überladene Version führt keine Addition mehr durch, sondern der übergebene Bin?roperator wird auf das Element angewendet.
partielle_Summe: Erstellen Sie eine neue Sequenz, in der jeder Elementwert die Summe aller Elemente vor dieser Position im angegebenen Bereich darstellt. Die überladene Version verwendet eine benutzerdefinierte Operation anstelle einer Addition.
inner_product: Bilden Sie das innere Produkt zweier Folgen (multiplizieren Sie die entsprechenden Elemente und summieren Sie dann) und addieren Sie das innere Produkt zu einem Eingabeanfangswert. Die überladene Version verwendet benutzerdefinierte Aktionen.
angrenzende_Differenz: Erstellen Sie eine neue Sequenz. Jeder neue Wert in der neuen Sequenz repr?sentiert die Differenz zwischen dem aktuellen Element und dem vorherigen Element. Die überladene Version berechnet die Differenz zwischen benachbarten Elementen mithilfe der angegebenen Bin?roperation.

<六>Generierungs- und Mutationsalgorithmen (6)
füllen: Weisen Sie den Eingabewert allen Elementen innerhalb des Flag-Bereichs zu.
fill_n: Weisen Sie den Eingabewert allen Elementen im Bereich vom ersten bis zum ersten n zu.
for_each: Verwenden Sie die angegebene Funktion, um iterativ auf alle Elemente im angegebenen Bereich zuzugreifen und den angegebenen Funktionstyp zurückzugeben. Diese Funktion darf keine Elemente in der Sequenz ?ndern.
generieren: Rufen Sie die Eingabefunktion kontinuierlich auf, um den angegebenen Bereich zu füllen.
generic_n: Füllen Sie ?hnlich wie bei der Funktion ?Generieren“ n Elemente ab dem angegebenen Iterator aus.
Transformation: Wenden Sie die Eingabeoperation auf jedes Element im angegebenen Bereich an und generieren Sie eine neue Sequenz. Die überladene Version arbeitet mit einem Elementpaar, wobei ein Element aus einer anderen Eingabesequenz stammt. Die Ergebnisse werden in den angegebenen Container ausgegeben.

<算> Beziehungsalgorithmus (8) <七> Gleich: Wenn die beiden Sequenzen im markierten Bereich gleich sind und auf TRUE zurückgehen. Die überladene Version verwendet den Eingabeoperator anstelle des standardm??igen Gleichheitsoperators.
umfasst: Bestimmt, ob alle Elemente im ersten angegebenen Bereich im zweiten Bereich enthalten sind. Verwenden Sie den <-Operator des zugrunde liegenden Elements, um erfolgreich ?true“ zurückzugeben. Die überladene Version verwendet die Benutzereingabefunktion.
lexicographical_compare: Zwei Sequenzen vergleichen. Die überladene Version verwendet benutzerdefinierte Vergleichsoperationen. <操作符，成功返回true。重載版本使用用戶輸入的函數(shù)。
max: Gibt das gr??ere der beiden Elemente zurück. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
max_element: Gibt einen ForwardIterator zurück, der das gr??te Element in der Sequenz angibt. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
min: Gibt das kleinere der beiden Elemente zurück. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
min_element: Gibt einen ForwardIterator zurück, der auf das kleinste Element in der Sequenz verweist. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
Nichtübereinstimmung: Vergleicht zwei Sequenzen parallel, zeigt die erste nicht übereinstimmende Position an und gibt ein Iteratorpaar zurück, das die Position des ersten nicht übereinstimmenden Elements markiert. Wenn alle übereinstimmen, wird der letzte jedes Containers zurückgegeben. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.

Set-Algorithmus (4)<八> set_union: Konstruieren Sie eine geordnete Sequenz, die alle sich nicht wiederholenden Elemente in den beiden Sequenzen enth?lt. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
set_intersection: Konstruiert eine geordnete Sequenz, in der Elemente in beiden Sequenzen vorhanden sind. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
set_difference: Konstruiert eine geordnete Sequenz, die nur Elemente beh?lt, die in der ersten Sequenz, aber nicht in der zweiten vorhanden sind. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
set_symmetric_difference: Konstruieren Sie eine geordnete Sequenz, die die symmetrische Differenz (Vereinigungsschnittpunkt) zweier Sequenzen annimmt.

Heap-Algorithmus (4)<九> make_heap: Erzeugt einen Heap aus den Elementen im angegebenen Bereich. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
pop_heap: entfernt nicht tats?chlich das gr??te Element aus dem Heap, sondern ordnet den Heap neu an. Es tauscht First und Last-1 aus und generiert dann einen Heap neu. Sie k?nnen die Rückseite des Containers verwenden, um auf das ?popped“-Element zuzugreifen, oder pop_back verwenden, um es tats?chlich zu l?schen. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.
push_heap: Angenommen, first to last-1 ist ein gültiger Heap, die dem Heap hinzuzufügenden Elemente werden an der Position last-1 gespeichert und der Heap wird neu generiert. Bevor auf diese Funktion verwiesen wird, muss das Element in den Container eingefügt werden. Die überladene Version verwendet die angegebene Vergleichsoperation.
sort_heap: Ordnet die Sequenz innerhalb des angegebenen Bereichs neu. Es wird davon ausgegangen, dass die Sequenz ein geordneter Heap ist. Die überladene Version verwendet einen benutzerdefinierten Vergleichsvorgang.

4. Adapter

STL stellt drei Containeradapter bereit: Queue, Priority_Queue und Stack. Diese Adapter sind Wrapper, die einen bestimmten Sequenzcontainer in Vektor, Liste und Deque einschlie?en. Hinweis: Der Adapter stellt keinen Iterator bereit und kann nicht mehrere Elemente gleichzeitig einfügen oder l?schen. Nachfolgend finden Sie eine Zusammenfassung der einzelnen Adapter.

(1) Stapelverwendung

#include

Vorlage
Klassenstapel < typename T, typename Container=deque >

kann drei Standardauftr?ge verwenden Einer der Container Vecotr, Deque (Standard) oder List dient als zugrunde liegendes Modell des Stapels.

bool stack::empty() //判斷堆棧是否為空
void stack::pop() //彈出棧頂數(shù)據(jù)
stack::push(T x) //壓入一個數(shù)據(jù)
stack::size_type stack::size() //返回堆棧長度
T stack::top() //得到棧頂數(shù)據(jù)

代碼示例：

stack<int> intDequeStack;  
stack<int,vector<int>> intVectorStack;  
stack<int,list<int>> intListStack;

2）queue用法

#include
template > class queue;

第一個參數(shù)指定要在queue中存儲的類型，第二個參數(shù)規(guī)定queue適配的底層容器，可供選擇的容器只有dequeue和list。對大多數(shù)用途使用默認的dequeue。

queue<T>::push(T x)
void queue<T>::pop()
T queue<T>::back()
T queue<T>::front()
queue<T>::size_type 
queue<T>::size()
bool queue<T>::empty()

代碼示例：

queue intDequeQueue;
queue> intListQueue;

（3）priority_queue用法

#include
template , typename Compare = less > class priority_queue;

priority_queue也是一個隊列，其元素按有序順序排列。其不采用嚴格的FIFO順序，給定時刻位于隊頭的元素正是有最高優(yōu)先級的元素。如果兩個元素有相同的優(yōu)先級，那么它們在隊列中的順序就遵循FIFO語義。默認適配的底層容器是vector，也可以使用deque，list不能用，因為priority_queue要求能對元素隨機訪問以便進行排序。

priority_queue<T>::push(T x)
void priority_queue<T>::pop()
T priority_queue<T>::top()
priority_queue<T>::size_type 
priority_queue<T>::size()
bool priority_queue<T>::empty()

代碼示例：

priority_queue< int, vector, greater >
priority_queue< int, list, greater >

標準庫默認使用元素類型的<操作符來確定它們之間的優(yōu)先級關系，用法有三：（下文轉(zhuǎn)自http://www.cnblogs.com/vvilp/articles/1504436.html）

優(yōu)先隊列第一種用法，通過默認使用的<操作符可知在整數(shù)中元素大的優(yōu)先級高。

priority_queue qi;

示例中輸出結(jié)果為：9 6 5 3 2

優(yōu)先隊列第二種用法，建立priority_queue時傳入一個比較函數(shù)，使用functional.h函數(shù)對象作為比較函數(shù)。

priority_queue, greater >qi2;

示例2中輸出結(jié)果為：2 3 5 6 9

優(yōu)先隊列第三種用法，是自定義優(yōu)先級。

struct node 
{
     friend bool operator< (node n1, node n2)
     {
         return n1.priority < n2.priority;
     } 
     int priority;
     int value; 
}; 
priority_queue<node> qn;

在示例3中輸出結(jié)果為：

優(yōu)先級? 值

9????????? 5

8????????? 2

6????????? 1

2????????? 3

1????????? 4

在該結(jié)構(gòu)中，value為值，priority為優(yōu)先級。通過自定義operator編譯不通過。