Vi har diskuteret qsort() i C. C++ STL giver en lignende funktionssortering, der sorterer en vektor eller et array (elementer med tilfældig adgang)
Det kræver generelt to parametre, den første er punktet for arrayet/vektoren, hvorfra sorteringen skal begynde, og den anden parameter er længden op til, som vi ønsker, at arrayet/vektoren skal sorteres. Den tredje parameter er valgfri og kan bruges i tilfælde som hvis vi ønsker at sortere elementerne leksikografisk.
Som standard sorterer funktionen sort() elementerne i stigende rækkefølge.
Nedenfor er et simpelt program til at vise, hvordan sort().
CPP
// C++ program to demonstrate default behaviour of> // sort() in STL.> #include> using> namespace> std;> int> main()> {> >int> arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };> >int> n =>sizeof>(arr) />sizeof>(arr[0]);> >/*Here we take two parameters, the beginning of the> >array and the length n upto which we want the array to> >be sorted*/> >sort(arr, arr + n);> >cout <<>'
Array after sorting using '> >'default sort is :
'>;> >for> (>int> i = 0; i cout << arr[i] << ' '; return 0; }> |
>
>Produktion
Array after sorting using default sort is : 0 1 2 3 4 5 6 7 8 9>
Tidskompleksitet: O(N log N)
Hjælpeplads: O(1)
Hvordan sorterer man i faldende rækkefølge?
sort() tager en tredje parameter, der bruges til at angive den rækkefølge, som elementer skal sorteres i. Vi kan sende funktionen greater() til at sortere i faldende rækkefølge. Denne funktion foretager en sammenligning på en måde, der sætter større elementer før.
CPP
// C++ program to demonstrate descending order sort using> // greater().> #include> using> namespace> std;> int> main()> {> >int> arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };> >int> n =>sizeof>(arr) />sizeof>(arr[0]);> >sort(arr, arr + n, greater<>int>>());> >cout <<>'Array after sorting :
'>;> >for> (>int> i = 0; i cout << arr[i] << ' '; return 0; }> |
>
>Produktion
Array after sorting : 9 8 7 6 5 4 3 2 1 0>
Tidskompleksitet: O(N log N)
Hjælpeplads: O(1)
Sorter kun arrayet i det givne interval: For at håndtere sådanne typer problemer skal vi blot nævne rækkevidden inde i sorteringsfunktionen.
Nedenfor er implementeringen af ovenstående case:
C++
// C++ program to demonstrate sort()> #include> using> namespace> std;> int> main()> {> >int> arr[] = { 0, 1, 5, 8, 9, 6, 7, 3, 4, 2 };> >int> n =>sizeof>(arr) />sizeof>(arr[0]);> >// Sort the elements which lies in the range of 2 to> >// (n-1)> >sort(arr + 2, arr + n);> >cout <<>'Array after sorting :
'>;> >for> (>int> i = 0; i cout << arr[i] << ' '; return 0; } // This code is contributed by Suruchi Kumari> |
>
>Produktion
Array after sorting : 0 1 2 3 4 5 6 7 8 9>
Tidskompleksitet: O(N log N)
Hjælpeplads: O(1)
Sådan sorteres i en bestemt rækkefølge?
Vi kan også skrive vores egen komparatorfunktion og videregive den som en tredje parameter. Denne komparatorfunktion returnerer en værdi; konverteres til bool, hvilket grundlæggende fortæller os, om det beståede første argument skal placeres før det beståede andet argument eller ej.
For eksempel: I koden nedenfor, antag, at intervallerne {6,8} og {1,9} sendes som argumenter i compareInterval-funktionen (komparatorfunktionen). Nu som i1.first (=6)
CPP
// A C++ program to demonstrate> // STL sort() using> // our own comparator> #include> using> namespace> std;> // An interval has a start> // time and end time> struct> Interval {> >int> start, end;> };> // Compares two intervals> // according to starting times.> bool> compareInterval(Interval i1, Interval i2)> {> >return> (i1.start } int main() { Interval arr[] = { { 6, 8 }, { 1, 9 }, { 2, 4 }, { 4, 7 } }; int n = sizeof(arr) / sizeof(arr[0]); // sort the intervals in increasing order of // start time sort(arr, arr + n, compareInterval); cout << 'Intervals sorted by start time :
'; for (int i = 0; i cout << '[' << arr[i].start << ',' << arr[i].end << '] '; return 0; }> |
>
>Produktion
Intervals sorted by start time : [1,9] [2,4] [4,7] [6,8]>
Tidskompleksiteten af std::sort() er:
streng i char java
- Bedste tilfælde – O(N log N)
- Gennemsnitlig tilfælde – O(N log N)
- Worst-case – O(N log N)
Rumkompleksitet: Den kan bruge O(log N) hjælperum.
C++
#include> #include> using> namespace> std;> template> <>class> T>> class> Comparator {>// we pass an object of this class as> >// third arg to sort function...> public>:> >bool> operator()(T x1, T x2)> >{> >return> x1 } }; template |
>
>Produktion
The array before sorting is : 1 5 8 9 6 7 3 4 2 0 The array after sorting is(asc) :0 1 2 3 4 5 6 7 8 9 The array after sorting is(desc) :9 8 7 6 5 4 3 2 1 0 The array after sorting is(asc but our comparator class) :0 1 2 3 4 5 6 7 8 9 The array after sorting is(asc but our comparator function) :0 1 2 3 4 5 6 7 8 9>
Tidskompleksitet: O(N log N)
Hjælpeplads: O(1)