Cs STL

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的元素是成对的键值/实值，内部的元素依据其值自动排序，Map内的相同数值的元素只能出现一次，Multimaps内可包含多个数值相同的元素，内部由二叉树实现（实际上基于红黑树(RB-tree）实现），便于查找；

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

容器的比较：

2.STL迭代器

Iterator（迭代器）模式又称Cursor（游标）模式，用于提供一种方法顺序访问一个聚合对象中各个元素,
而又不需暴露该对象的内部表示。或者这样说可能更容易理解：Iterator模式是运用于聚合对象的一种模式，通过运用该模式，使得我们可以在不知道对象内部表示的情况下，按照一定顺序（由iterator提供的方法）访问聚合对象中的各个元素。

迭代器的作用：能够让迭代器与算法不干扰的相互发展，最后又能无间隙的粘合起来，重载了*，＋＋，＝＝，！＝，＝运算符。用以操作复杂的数据结构，容器提供迭代器，算法使用迭代器；

常见的一些迭代器类型：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迭代器的所有功能，还拥有更多的功能。

各个迭代器的功能如下：

迭代器的操作：

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

只有顺序容器和关联容器支持迭代器遍历，各容器支持的迭代器的类别如下：

3.STL算法

STL算法部分主要由头文件,,组成。要使用 STL中的算法函数必须包含头文件，对于数值算法须包含，中则定义了一些模板类，用来声明函数对象。
STL中算法大致分为四类：
1）、非可变序列算法：指不直接修改其所操作的容器内容的算法。
2）、可变序列算法：指可以修改它们所操作的容器内容的算法。
3）、排序算法：包括对序列进行排序和合并的算法、搜索算法以及有序序列上的集合操作。
4）、数值算法：对容器内容进行数值计算。

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。重载版本使用用户输入的函数。
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() //弹出栈顶数据
stack::push(T x) //压入一个数据
stack::size_type stack::size() //返回堆栈长度
T stack::top() //得到栈顶数据

代码示例：

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

2）queue用法

#include
template > class queue;

第一个参数指定要在queue中存储的类型，第二个参数规定queue适配的底层容器，可供选择的容器只有dequeue和list。对大多数用途使用默认的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顺序，给定时刻位于队头的元素正是有最高优先级的元素。如果两个元素有相同的优先级，那么它们在队列中的顺序就遵循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 >

标准库默认使用元素类型的<操作符来确定它们之间的优先级关系，用法有三：（下文转自http://www.cnblogs.com/vvilp/articles/1504436.html）

优先队列第一种用法，通过默认使用的<操作符可知在整数中元素大的优先级高。

priority_queue qi;

示例中输出结果为：9 6 5 3 2

优先队列第二种用法，建立priority_queue时传入一个比较函数，使用functional.h函数对象作为比较函数。

priority_queue, greater >qi2;

示例2中输出结果为：2 3 5 6 9

优先队列第三种用法，是自定义优先级。

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

在示例3中输出结果为：

优先级  值

9          5

8          2

6          1

2          3

1          4

在该结构中，value为值，priority为优先级。通过自定义operator编译不通过。