ANSI C Funkcja w języku ANSI C (dla tablicy o elementach typu float i długości typu int). Wersja klasyczna: typedef float TYP;

void QuickSort(TYP *T, int Lo, int Hi) { int i,j; TYP x; x = T[(Lo+Hi)>>1]; //można wylosować element dzielący, np: x=T[rand%(Hi-Lo)+Lo+1], dzięki temu zabezpieczymy się dość skutecznie przed ukwadratowieniem. i = Lo; j = Hi; do

while (T[i] x) --j; if (i i) QuickSort(T, i, Hi);

Wersja Lomuto: void quicksortlomuto(int table[], int first, int last) { int i = first-1; int temp, j; int pivot = table[last]; for(j=first; ji+1) quicksortlomuto(table, i+1, last);

Wersja hybrydowa(rekurencyjnie dzieli do 10 elementów, jeżeli jest mniej pozostałe sortuje przy pomocy sortowania przez wybieranie): void quicksorthybrid(int table[], int first, int last) { if (last-first>9) { int i = first; int j = last; int pivot = table[(first+last)>>1]; while (i pivot ) --j; if (i<=j)

int temp = table[i]; table[i] = table[j]; table[j] = temp; ++i; --j;

if (first first && klucz<table[j-1] )

table[j] = table[j-1]; j--;

table[j] = klucz;

C++ Implementacja w języku C++ przy założeniu, że elementem osiowym jest środkowy element tablicy.

void quicksort(int tab[], int left, int right){ int i=left; int j=right; int x=tab[(left+right)>>1]; do{ while(tab[i]x) j--; if(ii) quicksort(tab,i,right); }

C# void QuickSort(IList items, int left, int right) where T : IComparable { int i = left; int j = right; T x;

x = items[(left + right) >> 1]; do

while (items[i].CompareTo(x) 0) j--; //items[j] > x

if (i (items, i, j); i++; j--;

while (i i) QuickSort(items, i, right); }

void Swap(IList list, int left, int right) { T temp = list[left]; list[left] = list[right]; list[right] = temp; }

Haskell quicksort :: Ord a => [a] -> [a] quicksort [] = [] quicksort (p:xs) = (quicksort lesser) ++ [p] ++ (quicksort greater) where lesser = filter (= p) xs

Java public static void quicksort(int[] a, int lo, int hi) { // lo is the lower index, hi is the upper index // of the region of array a that is to be sorted int i=lo, j=hi, h; int x=a[(lo+hi)/2]; // partition do

while (a[i]x) j--; if (i<=j)

h=a[i]; a[i]=a[j]; a[j]=h; i++; j--;

} while (i<=j); // recursion if (lo<j) quicksort(a, lo, j); if (i<hi) quicksort(a, i, hi);

Pascal Kod szybkiego sortowania tablicy w Pascalu (z losowym wyborem elementu dzielącego, lecz bez pozostałych usprawnień).

Procedure Quicksort (Var t:tab; l,r:Integer); Var pivot,b,i,j:Integer; Begin If l = t[j]; b:=t[i]; t[i]:=t[j]; t[j]:=b Until i >= j; t[j]:=t[i]; t[i]:=b; Quicksort(t,l,i-1); Quicksort(t,i,r) End End; Wywoływanie dla tablicy o długości n: quicksort(tablica,1,n);.

W Delphi algorytm quicksort jest domyślnie wbudowany w klasę TList i wszystkie klasy pochodne. Jako parametr wywołania metody Sort należy podać wskaźnik do funkcji porównującej dwa elementy listy.

JavaScript Na podstawie powyższej implementacji w JavaScript. function quicksort(a, lo, hi) { var i=lo; var j=hi; var x=a[(lo+hi)/2]; // partition

do

while (a[i]x) j--; if (i<=j)

h=a[i]; a[i]=a[j]; a[j]=h; i++; j--;

} while (i<=j);

// recursion if (lo<j) quicksort(a, lo, j); if (i<hi) quicksort(a, i, hi); return a;

var mess = new Array(12,54,23,87,15,43,89,65,34,23,76); quicksort(mess, 0, 10);

PHP Na podstawie implementacji w Javie:

$x) $j--; if($i <= $j){ $h = $tab[$i]; $tab[$i] = $tab[$j]; $tab[$j] = $h;

$i++; $j--;

}while($i int(0) => int(12) => int(34) => int(78) => int(543) } */ ?>

Python Dwie implementacje w języku Python. Pierwsza jest szybsza (mniej kopiowania i tworzenia tymczasowych tablic), druga bardziej czytelna.

def qsort(arr, l=0, r=None): if r is None: r = len(arr) - 1 i, j = l, r pivot = arr[(l + r) / 2] while i pivot: j -= 1 if i i: qsort(arr, i, r)

def qsort(arr): if len(arr) = p] return qsort(left) + [p] + qsort(right)

Ruby Dwie implementacje w języku Ruby. Pierwsza jest szybsza (mniej kopiowania i tworzenia tymczasowych tablic), druga bardziej czytelna.

def qsort(arr, l=0, r=arr.size-1) i, j = l, r pivot = arr[(l + r) / 2] while i pivot if i i end

def qsort(arr) return arr if arr.size pivot > el)), arr filter (el => pivot == el), qsort(arr filter (el => pivot >;

fun x > (y::ys) = if (y >= x) then y::(x >> ys) else x >> ys | x >> nil = nil;

fun quicksort nil = nil | quicksort [x] = [x] | quicksort (x::xs) = quicksort(x > xs))

(* np. sortuj int list *) quicksort [108,14,13,15];

(* albo krócej *) fun qs [] = [] | qs (x::xs) = (qs (filter (fn p => p p>= x) xs)))