|
Tez saralash (quicksort)
Tez saralash (quicksort) algoritmi - Charlz Xoar tomonidan yaratilgan mashxur saralash algoritmidir. Ushbu algoritm n ta elementdan iborat massivni eng uzog’i bilan O(n2) vaqtda saralaydi. Biroq algoritm bajarilish tezligining matematik kutilmasi O(n log n) ga teng va u boshqa shunday tezlikda bajariluvchi algoritmlardan tezroq ishlaydi.
Bu algoritm “bo’lib ol va egalik qil” tamoyilining yaqqol misolidir. Bu algotirm rekursiv bo’lib, o’rtacha N*log2N ta solishtirish natijasida saralaydi. Algoritm berilgan massivni saralash uchun uni 2 taga bo’lib oladi. Bo’lib olish uchun ixtiyoriy elementni tanlab undan 2 ta qismga ajratiladi. Lekin o’rtadagi elementni tanlab, massivning teng yarmidan 2 ga ajratgan ma’qul. Tanlangan kalit elementga nisbatan chapdagi va o’ngdagi har bir element solishtiriladi. Kalit elementdan kichiklar chapga, kattalar o’ng tomonga o’tkaziladi (rasm). Endi massivning har ikkala tomonida xuddi yuqoridagi amallar takrorlanadi. Ya’ni bu oraliqlarning o’rtasidagi elementlar kalit sifatida olinadi va h.k. Misol uchun rasmdagi massivni saralash algoritmini ko’rib chiqamiz.
1. Oraliq sifatida 0 dan n-1 gacha bo’lgan massivning barcha elementlarini olamiz.
2.Oraliq o’rtasidagi kalit elementni tanlaymiz, ya’ni key = ( < oraliq_boshi > + < oraliq_oxiri > ) / 2, i=, j=.
Quicksort algoritimida o’rinlashtrish.
3. Chapdagi i-elementni key bilan solishtiramiz. Agar key kichik bo’lsa, keyingi qadamga o’tamiz. Aks holda i++ va shu qadamni takrorlaymiz.
4. O’ngdagi j-element bilan key solishtiriladi. Agar key katta bo’lsa, keyingi qadamga o’tamiz, aks holda j-- va shu qadamni takrorlaymiz.
5. i- va j-elementlarning o’rni almashtiriladi. Agar i<=j bo’lsa, 3-qadamga o’tiladi. Birinchi o’tishdan keyin tanlangan element o’zining joyiga kelib joylashadi.
6. Endi shu ko’rilayotgan oraliqda key kalitning chap tomonida elementlar mavjud bo’lsa, ular ustida yuqoridagi amallarni bajarish lozim, ya’ni ko’riladigan oraliq 0 dan key-1 gacha deb belgilanadi va 2-qadamga o’tiladi. Aks holda keyingi qadamga o’tiladi.
7. Endi shu ko’rilayotgan oraliqda key kalitning o’ng tomonida elementlar mavjud bo’lsa, ular ustida yuqoridagi amallarni bajarish lozim, ya’ni ko’riladigan oraliq key+1 dan n-1 gacha deb belgilanadi va 2-qadamga o’tiladi. Aks holda algoritm tugaydi. Shu algoritmga misol ko’rib chiqamiz.
Tezkor saralash uchun C ++ kodi
#include
#include
using namespace std;
// funtion to split array around pivot
int split(int arr[],int lo,int hi)
{
int i = lo-1;
// select last element as pivot
int pivot = hi;
// All elements less than arr[pivot] are brought to left side
// This splits array into two parts
// array -> [left subarr] [pivot] [right subarr]
for(int j=lo;j
{
if(arr[j] < arr[pivot])
{
i++;
swap(arr[i],arr[j]);
}
}
// Bring pivot element to it's correct postion in sorted array
// by swapping smallest element of right subarray with pivot
swap(arr[i+1],arr[pivot]);
return i+1;
}
// Service function to recursively perfrom split()
// for left and right subarrays
void quickSortServe(int arr[],int lo,int hi)
{
if(lo < hi)
{
int pivot = split(arr,lo,hi);
// recursively perfrom split() for right and left subarrays
quickSortServe(arr,lo,pivot-1);
quickSortServe(arr,pivot+1,hi);
}
}
// Function to implement quick sort algorithm
void quickSort(int arr[],int size)
{
quickSortServe(arr,0,size-1);
}
int main()
{
int arr[] = {8,9,5,2,3,1,4};
int n = sizeof(arr)/sizeof(arr[0]);
quickSort(arr,n);
for(int i=0;i
cout<
return 0;
}
++++++++++++++++++++++++++++++++++
#include
#include
#include
template< typename BidirectionalIterator, typename Compare >
void quick_sort( BidirectionalIterator first, BidirectionalIterator last, Compare cmp ) {
if( first != last ) {
BidirectionalIterator left = first;
BidirectionalIterator right = last;
BidirectionalIterator pivot = left++;
while( left != right ) {
if( cmp( *left, *pivot ) ) {
++left;
} else {
while( (left != --right) && cmp( *pivot, *right ) )
;
std::iter_swap( left, right );
}
}
--left;
std::iter_swap( first, left );
quick_sort( first, left, cmp );
quick_sort( right, last, cmp );
}
}
template< typename BidirectionalIterator >
inline void quick_sort( BidirectionalIterator first, BidirectionalIterator last ) {
quick_sort( first, last,
std::less_equal< typename std::iterator_traits< BidirectionalIterator >::value_type >()
);
}
Do'stlaringiz bilan baham: | 
