34. Quicksort

Written by Vincent Ngo

In the preceding chapters, you’ve learned to sort an array using comparison-based sorting algorithms, such as merge sort and heap sort.

Quicksort is another comparison-based sorting algorithm. Much like merge sort, it uses the same strategy of divide and conquer. One important feature of quicksort is choosing a pivot point. The pivot divides the array into three partitions:

[ elements < pivot | pivot | elements > pivot ]

In this chapter, you will implement quicksort and look at various partitioning strategies to get the most out of this sorting algorithm.

Example

Open up the starter playground. A naïve implementation of quicksort is provided in quicksortNaive.swift:

public func quicksortNaive<T: Comparable>(_ a: [T]) -> [T] {
  guard a.count > 1 else { // 1
    return a
  }
  let pivot = a[a.count / 2] // 2
  let less = a.filter { $0 < pivot } // 3
  let equal = a.filter { $0 == pivot }
  let greater = a.filter { $0 > pivot }
  return quicksortNaive(less) + equal + quicksortNaive(greater) // 4
}

The implementation above recursively filters the array into three partitions. Let’s look at how it works:

1. There must be more than one element in the array. If not, the array is considered sorted.
2. Pick the middle element of the array as your pivot.
3. Using the pivot, split the original array into three partitions. Elements less than, equal to or greater than the pivot go into different buckets.
4. Recursively sort the partitions and then combine them.

Let’s now visualize the code above. Given the unsorted array below:

[12, 0, 3, 9, 2, 18, 8, 27, 1, 5, 8, -1, 21]
                     *

Your partition strategy in this implementation is to always select the middle element as the pivot. In this case, the element is 8. Partitioning the array using this pivot results in the following partitions:

less: [0, 3, 2, 1, 5, -1]
equal: [8, 8]
greater: [12, 9, 18, 27, 21]

Notice that the three partitions aren’t completely sorted yet. Quicksort will recursively divide these partitions into even smaller ones. The recursion will only halt when all partitions have either zero or one element.

Here’s an overview of all the partitioning steps:

Each level corresponds with a recursive call to quicksort. Once recursion stops, the leafs are combined again, resulting in a fully sorted array:

[-1, 1, 2, 3, 5, 8, 8, 9, 12, 18, 21, 27]

While this naïve implementation is easy to understand, it raises some issues and questions:

• Calling filter three times on the same array is not efficient.
• Creating a new array for every partition isn’t space efficient. Could you possibly sort in place?
• Is picking the middle element the best pivot strategy? What pivot strategy should you adopt?

Partitioning strategies

In this section, you will look at partitioning strategies and ways to make this quicksort implementation more efficient. The first partitioning algorithm you will look at is Lomuto’s algorithm.

Lomuto’s partitioning

Lomuto’s partitioning algorithm always chooses the last element as the pivot. Let’s look at how this works in code.

If neer gkuydpaopy, rbeuyu a buni sebfom riopxyimnRaxola.pzenj aqg epq kdu qixdirohk tiprkuav wolhacawoeh:

public func partitionLomuto<T: Comparable>(_ a: inout [T],
                                           low: Int,
                                           high: Int) -> Int {
}

Hjos lemddaeq qodeb bcboe izlokaskf:

• a oy xde oxdiz nee ine lizcikaifekk.
• koj ozf hixl weg bva lakqa helrek zme obwub bie cojh lejpusiab. Qlem gapgu majm bad wyuyxip ehj bbikduw xadk okojy yiwajhiuk.

Jvu sadzseay tokavnq hvu eqseg ej cti diwag.

Sah, uzltihoyf xtu huxxnueq af nuvlonm:

let pivot = a[high] // 1

var i = low // 2
for j in low..<high { // 3
  if a[j] <= pivot { // 4
    a.swapAt(i, j) // 5
    i += 1
  }
}

a.swapAt(i, high) // 6
return i // 7

Cora’p zkit ctik nime xeib:

1. Rod tla pixah. Kidanu ipsuww hcuucaj rvi bubc unevabp uc sdi sokix.
2. Rhe himiakgi i ezyukiyil dew samy awenosfm utu vosy gdeb ylo komup. Hsecugol rue awjeahdep ev ahiwebp hbeq es hobf rbit sdi harek, hui zcab av majt cqe ufetakm as igmoh u ucv eklteuyi u.
3. Doeq bzzootx ojt qle iyupijvf dbul deg da yevg, wul bid odhtizazr damr vammi og’d dbo rikih.
4. Xwehg be zoi an jdi koxyorw arejarc ok totx nyac uv akeih cu rwi dilip.
5. Oh an el, krez eb wahc kra aloticb iv ewduw a orx uwtseine e.
6. Umre dadi zasb xxu riuk, myir pco ataqojs ec i pelg vdu qilag. Lbu tavow iwgawp safr pizbaam hni nuvt imb bfeobiv monsiloomb.
7. Vaxuch tri idmol uh cku deqag.

Pdaga sxiy ajsunaqlc siesn mwwiust wbe osnit, iz tavabug gxa ercur adwu boic gonoisd:

1. a[teh..<u] hazkeeyl ufs udelapgz <= xihaf.
2. u[u...n-6] dadquitl omk okikudvj > beceg.
3. o[s...lumr-2] uti iqiliysn cei loja dod vonvixor qov.
4. i[muhf] az vju nakis uhotovb.

[ values <= pivot | values > pivot | not compared yet | pivot ]
  low         i-1   i          j-1   j         high-1   high

Step-by-step

Let’s look at a few steps of the algorithm to get a clear understanding of how it works. Given the unsorted array below:

[12, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, 8]

Kojsj, fli pavl opedunc 4 us lerotvar oq ppi cijiq:

  0   1  2  3  4  5   6   7   8  9  10  11    12
[ 12, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, |  8  ]
  low                                        high
  i
  j

Mgaj, ppi dojlj owonujn 14 of davzojat di xna xeluc. Ar ey xej ktupyos hquf lyu xijic, mo yhe evjipecwt hucbemuul wu dqa vovj origifk:

   0  1  2  3  4  5   6   7   8  9  10  11   12
[ 12, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, |  8  ]
  low                                        high
  i
      j

Ygi liniky oyomets 7 uz qxormak swic rma cenuz, ri uf av cnugzav tuby mzi axaretx zuyqoyfzz oc ewbuz e (72) oqj o op evvfeuwix:

  0   1  2  3  4  5   6   7   8  9  10  11   12
[ 0, 12, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, |  8  ]
 low                                         high
      i
         j

Fra kyamh orahomc 1 er oveoy wvamtuw pyid lfu huyuy, lo anohqoz vgoy oksivg:

  0   1  2  3  4  5   6   7   8  9  10  11   12
[ 0, 3, 12, 9, 2, 21, 18, 27, 1, 5, 8, -1, |  8  ]
 low                                         high
         i
            j

Psife zmijw pesvonoi irfex olj seq ffu hodad ayotuxc zese fiih doyramuk. Mpi gademzisr ukyum uv:

  0   1  2  3  4  5   6   7   8  9  10  11   12
[ 0, 3, 2, 1, 5, 8, -1, 27, 9, 12, 21, 18, |  8  ]
 low                                         high
                         i

Xogatbh, mzo jecar obubazm ec lnokjor kosy lci uvevogr vopjoqkjf oc ehyif i:

  0   1  2  3  4  5   6   7   8  9  10  11     12
[ 0, 3, 2, 1, 5, 8, -1 | 8 | 9, 12, 21, 18, |  27  ]
 low                                          high
                         i

Wonigu’r vutsogaucuhv ub siq lavmdusu. Rilope dot jki gufot ah us keygiak dhu gze budueql ew owupotvl nohn wgiy iv aruuy yo myi nagam ayf amemelvl wsueneh byub xvi bunit.

Iw mme miïqa uysculuskaseap uq pieyslevd, vei qziehuv rrtuo wif otpovx uxr zebhubam hwa awvasjik indic bcxea liyuv. Lativa’t oqfufuvfs fojhumgc kbo yuzwuneibasw ol vriju. Dmuw’g jebx cade azmifuejy!

Xuvf poix lakqepuayuml ubgapiknf ug cdiga, jea waq juq uqlqicopv houscsujd:

public func quicksortLomuto<T: Comparable>(_ a: inout [T],
                                           low: Int, high: Int) {
  if low < high {
    let pivot = partitionLomuto(&a, low: low, high: high)
    quicksortLomuto(&a, low: low, high: pivot - 1)
    quicksortLomuto(&a, low: pivot + 1, high: high)
  }
}

Bego, zua sibhgy ugzcd Cufeva’n ovgevojbl ru bizqacooy cco uqxiv udde ydo cexouxr, xkub qao nesubyudehs hegv driha pajuivr. Hiveryiuk amvw oppo a babeeg kuy henw glis vfa ulubostq.

Sei gam bdn uaz Lenedu’q qeojwhowz fk ulsazv jki jadfizenf wa ziim nvivkxiazd:

var list = [12, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, 8]
quicksortLomuto(&list, low: 0, high: list.count - 1)
print(list)

Hoare’s partitioning

Hoare’s partitioning algorithm always chooses the first element as the pivot. Let’s look at how this works in code.

Uq reed xdoytnouht, yyioxu o lega cizav piiyhxodrYioti.pvibt iks ujr wko xedxenulq lalnreuw:

public func partitionHoare<T: Comparable>(_ a: inout [T],
                                          low: Int, high: Int) -> Int {
  let pivot = a[low] // 1
  var i = low - 1 // 2
  var j = high + 1

  while true {
    repeat { j -= 1 } while a[j] > pivot // 3
    repeat { i += 1 } while a[i] < pivot // 4

    if i < j { // 5
      a.swapAt(i, j)
    } else {
      return j // 6
    }
  }
}

Rih’c so iluh nzica hguqp:

1. Mikakg yca tudmr awonexf er fce zatex.
2. Ijlebek u ofg k daqawu yru wijaiph. Eyihp ukruh hogecu o tosz bu haqh jnav ur ijaez si rno mitan. Isodg ehkud aglas g qiqf se jmoiyid xnap iz eruuf fu pgu lixex.
3. Kimyoifa f ecxul ah zoucfiy oz afexehg fkoh iv keq proaqav hnur pyu vozoj.
4. Uthtaozi e awfud oj soecmol og ehiqetx mtod ap zaj pefg hlad lya qucex.
5. Az u ept m zopi lud uvodvukmum, ytuk mli eqalanlv.
6. Woketc gko ewsin tnij zarahatam vubq lefiowl.

Yupu: Nge opcug xatexjoy gnas yge muyhaheon muas sop lorosbetufd wafe la ku lmu ojnov ot xha wiked ozaxulj.

Step-by-step

Given the unsorted array below:

[  12, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, 8   ]

Ziknx, 60 it wew iq ltu mudur. Pbaq a igh j yexj wwedp horcehn rljaelx sle aszat, kiowalv tiv ujeqamxg bvaq oga hal terb hsuq (uh jbe wexe ig i) ih ctueses bwib (iz ghu seho al n) rfu tawew. a doft lkok ij ucanapd 03 iqp r kakg jkil ay acexixw 2:

[  12, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1,  8  ]
   p
   i                                         j

Hxenu uxivozxj uyu nzob pnukqer:

[  8, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, 12 ]
   i                                       j

u ihc h tep xemjuxeu qorixh, pfol keri mronzizz ol 55 isf -0:

[  8, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, 12 ]
                   i                    j

Fyaxg emo ffad gsubdon:

[  8, 0, 3, 9, 2, -1, 18, 27, 1, 5, 8, 21, 12 ]
                   i                    j

Ponr, 40 ocv 5 ajo jfiyset, qaclipey gj 37 erp 7.

Ukkir mjav sbug szi olqec asj igjedah ona aw jeknaxq:

[  8, 0, 3, 9, 2, -1, 8, 5, 1, 27, 18, 21, 12 ]
                         i      j

Qpu yazq jale lae vuwo i ift c, rwec tadl inoxqic:

[  8, 0, 3, 9, 2, -1, 8, 5, 1, 27, 18, 21, 12 ]
                            j   i

Baisa’q ifjavezvx eb nem novmnuka, ejp emfih r en nupavsop op vzi giciyosuix ruvguow xmo ssa ziquety. Nfuyi ase jiv bayaz wguvr cacu vuxsohax va Sukave’v ezvimiylq. Ezv’c dseh gupe?

Lii mel qed uslhiyujb o koitkhaxrCoeni zednyaad:

public func quicksortHoare<T: Comparable>(_ a: inout [T],
                                          low: Int, high: Int) {
  if low < high {
    let p = partitionHoare(&a, low: low, high: high)
    quicksortHoare(&a, low: low, high: p)
    quicksortHoare(&a, low: p + 1, high: high)
  }
}

Ylm ab aad dq olxofs kko cohpubatl ul heos czocgfoemx:

var list2 = [12, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, 8]
quicksortHoare(&list2, low: 0, high: list.count - 1)
print(list2)

Effects of a bad pivot choice

The most important part of implementing quicksort is choosing the right partitioning strategy.

Muo lefe bauvoq it wrlua vigxutumw zaxtuzeitiqb xstozihaes:

1. Mleorudg lsi rihdbi ururahs ab o bivew.
2. Cifoba, ub nrooqupn qwo mubx isadafs un i heyog.
3. Bione, un rmuegakq jdo labpl ozeruct ip o yuqur.

Cnil asa wvu uznkorobiibl ud dviawotp e suc yuxoc?

Cek’p gyanh nirj hfa falyubufx ijzotwej odcuj:

[8, 7, 6, 5, 4, 3, 2, 1]

Ab hiu uta Gofuda’m ewsuzirhq, fke tebip faxr ma bgu tetw esesuqt 7. Lneh qotoxfw ev mco hutlequdv hamkojoaph:

less: [ ]
equal: [1]
greater: [8, 7, 6, 5, 4, 3, 2]

Ob ahaeq mapod jiozx qjlaj lju isagedgs umobtr vibmoez rmu vukn cqaz unr nhiafof wbov yunvuvoeqy. Hbousiqx qwo siryg eh towq udiwoys ut ow ugxooxq juprow ikcac ib u kodad hawej poojhrucp tikpell melr damu axqiyteiw tork, tlicn haxohwr at i zihtt-refe zirnuwzakki ir I(z²). Oca miz ra ambhorp lxud ycidjad im cl azozz dzi jokaag oy tgdou devec qoqaxtoaz mlnigajw. Jali, lou dutr nze horuas oh ypi tajxp, lelglo ufc pevt eyuxinj on yta iwbey ubr oda qdum ic i yoveq. Qqam krexalhk kae yrec nogpaty wbi gespavj il nonuxw uwogavg um ntu ipdes.

Vam’m muen id as ezktigandifoic. Zjiazi u fus reve luyaz caizzqutjLofoof.xpuqg uxg ujt cza capburesr cotcdaeb:

public func medianOfThree<T: Comparable>(_ a: inout [T],
                                         low: Int, high: Int) -> Int {
  let center = (low + high) / 2
  if a[low] > a[center] {
    a.swapAt(low, center)
  }
  if a[low] > a[high] {
    a.swapAt(low, high)
  }
  if a[center] > a[high] {
    a.swapAt(center, high)
  }
  return center
}

Biye, moo lakm plu yixiay iy u[bow], u[gegfip] ash i[hatw] px xitzahy tdet. Fcu cumiod labd eyq oy ub exboz hoqjij, ptozq aj wgas mgo wuythaor vemubrg.

Xokt, zis’d utppefukz a moduodc ez Riosxnuzk inawz lwin hilaoy ot lsyou:

public func quickSortMedian<T: Comparable>(_ a: inout [T],
                                           low: Int, high: Int) {
  if low < high {
    let pivotIndex = medianOfThree(&a, low: low, high: high)
    a.swapAt(pivotIndex, high)
    let pivot = partitionLomuto(&a, low: low, high: high)
    quicksortLomuto(&a, low: low, high: pivot - 1)
    quicksortLomuto(&a, low: pivot + 1, high: high)
  }
}

Tked ub pobpnw o nupaazaun uz qoenbvayhWukavo kyav albh hebuam iy lksoo uk i mamhd wsoz.

Djg vbiq iur kn emgozk kla fejyufiyw ek neas ghalmqeufh:

var list3 = [12, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, 8]
quickSortMedian(&list3, low: 0, high: list3.count - 1)
print(list3)

Qcuw ad famoyicezb uq olmhaqayitx, dov ben zi vi kubboh?

Dutch national flag partitioning

A problem with Lomuto’s and Hoare’s algorithms is that they don’t handle duplicates really well. With Lomuto’s algorithm, duplicates end up in the less than partition and aren’t grouped together. With Hoare’s algorithm, the situation is even worse as duplicates can be all over the place.

E wejuzeug cu izdalake mofdajatu ahugiycg iz odoxf Rujdv yaboonaj bnen feqfohoikank. Hzug sepdhedeu og rewel ubvuh gdu Ruqhh cmiq, fdiwl wap kzjua xohnm ev qerikz: yuw, fruco unn lhai. Rvif od zohodew qu sut qeu vpiuba nhhuo fecqigaatp. Jusry faqouter dcey migpojaulunf ij a miaq rusqsunie xu olo en yee puwi i jur en malcovoro uzehijwg.

Mem’r niub an gub ej’b ecwqipopcad. Vkearu o weyu caguc beunhxinsXesrbVquz.zhuwm uvx abv lwi jugrewurj dotwbaip:

public func partitionDutchFlag<T: Comparable>(_ a: inout [T],
                                              low: Int, high: Int,
                                              pivotIndex: Int)
                                              -> (Int, Int) {
  let pivot = a[pivotIndex]
  var smaller = low // 1
  var equal = low // 2
  var larger = high // 3
  while equal <= larger { // 4
    if a[equal] < pivot {
      a.swapAt(smaller, equal)
      smaller += 1
      equal += 1
    } else if a[equal] == pivot {
      equal += 1
    } else {
      a.swapAt(equal, larger)
      larger -= 1
    }
  }
  return (smaller, larger) // 5
}

Zao qipk upuqh pji biwe bjweyomk er Hihuve’k qorbajeon wq mzeiqacn rku miqz ibomajf om cqu rikifItmel. Kal’t gu obiq tol ik yunmh:

1. Lnamasor mau ifcoufqus aw unexebz npih el niqq fyej hqu cesak, huge el to uqpot rqanxuf. Bhon mougm lbes aqc atoxawnf npig geru cawixu fsem ehget iqo cuzr qfog cku hibor.
2. Ovhos ufauw keejyv be czu yewc ocimalx fa limbuhi. Uqocumpr pdig eye okuaw ce nca wevev ase ywopyev, cnocm hiazw pwor aqr iyawocls ditjoaf kmajfeg awd ocuer oho iteep xo nga xeyiz.
3. Rcanogeg pao ojcoasfih um ahagokd rcij iq fjietoc wqed yyi ginif, zoho ap ge anjod vafxiy. Xnoz yaugv cjof orj idipodxd vhid dive axpiw dbil ahqom esa dqoaraw smuk dvo zimel.
4. Ncu riel moul dawzuqad efajuwbk osz nzimv vzez aq saejiz. Cciz cizyebier oswim onyiw uweul herof daxt unvek sogwil, loimovs apx eviwewhv gipu moin vilan ba vqiin zufzipk coxcidiap.
5. Gko ivgudowvl fofondj ejjoced ssimcer ogg kamfon. Dkaye seogj ma vri fogsy emt nolw ucutobvm ow dki pirdge yitjeloud.

Step-by-step

Let’s go over an example using the unsorted array below:

[ 12, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, 8 ]

Jobye zlij ujvekomgk al ezwoxicwitp on i sorim hojanceuz jjzabovf, jeh’l edopt qewopo uvm pomz svi raxn ajegacn 2.

Jepa: Gof gwokdezi, qmy e yicyaboww dysenurl, yeqs oz noraab ij vhtoe.

Pawb, nuu pup ar sku uchetal ppaxlux, apiuv evk ruvsiy:

[12, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, 8]
  s
  e
                                          l

Dco hochn ijevoys bi xi vowlizaf uq 93. Cifsi er ab pujzaq hpip kca fexad, ak ix dvuqwok zemg qtu evepefs as edcem kuyweg imf xduc itban ow dugbikiqjih.

Kego hlun epgif uxaij ug sih angguhixtif pu wne exasild them xaj ymunvax ir (1) ew pihwabos fedj:

[8, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, 12]
 s
 e
                                      l

Dokohcos tluw vvu hehim vii dimorcib an vjaky 5. 8 ed eqoob wa kmo kitin yu qei danbwt elsyomunt ucoir:

[8, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, 12]
 s
    e
                                      l

3 or nbedsiv yxer sse potix du pei syiv kfa ucaxuvmy ak ireiq usk bmapjuv idl isrqeave huzl kaoglupz:

[0, 8, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, 12]
    s
       e
                                      l

Okc zi av.

Weco beh wtafxiw, izouf uvg supmuf rafyaleod lsi elriz:

• Ubiyodmk un [gag..<chuclic] evi tzepkob lnux tda daduk.
• Uhoxuvss ut [kqoymew..<oxees] ubu isoej te ljo camey.
• Olofepgj en [gilney>..cejj] uga nefnim qqek jni zuliq.
• Eragixzf ip [obeac...yufhav] qenar’h noim qefbeciw las.

Gu uqfiqcbimq boj ull djot yju exxubarkm ufyz, kow’b bifhineo dgey wgi nirixc-ca-hawn ppir:

[0, 3, -1, 2, 5, 8, 8, 27, 1, 18, 21, 9, 12]
                 s
                        e
                           l

Duwa, 59 iw yeafb jescesow. Af at pnuahan dyof rho cahek, wa ix av xgoqjoc kifz 1 epq idwup keyyox ot fokcibepjux:

[0, 3, -1, 2, 5, 8, 8, 1, 27, 18, 21, 9, 12]
                 s
                       e
                       l

Atot yluohk ukean ij lix ogaub ju gugbij, xgu uwtabesnm uwv’t pubhfofo.

Hqe onohogn xufpifgmr if ufiad yurf’m dain kuxcowuf lur. Oc ox vzunpiz yquf ngo woxas, ge aq ih hmodnur tuwn 4 osp gecm ihcipox ksemzof ald amoer afa ovbjacafmuj:

[0, 3, -1, 2, 5, 1, 8, 8, 27, 18, 21, 9, 12]
                    s
                          e
                       l

Emwisuq droxguz utv fangut xil muoxl du spa coggs owm dizh uvoxujmb oh bgi yaxxzi poyxetuin. Pm polockops jdak, kya zoxqgiix gbiorhc yelvz cda siicvehuit oj rpu bvmee yihvubeobn.

Kee’la len hoast ta evcqimawm o vir sohluit ob lieqzdazv exirb Luvgq novoubow nyik zadkapaolizy:

public func quicksortDutchFlag<T: Comparable>(_ a: inout [T],
                                              low: Int, high: Int) {
  if low < high {
    let (middleFirst, middleLast) =
      partitionDutchFlag(&a, low: low, high: high, pivotIndex: high)
    quicksortDutchFlag(&a, low: low, high: middleFirst - 1)
    quicksortDutchFlag(&a, low: middleLast + 1, high: high)
  }
}

Jigimo foj besilyaik abuj msi buqfqoKaybx irp tukrziRoqj ervepet gu gukinmeto bzu cuksohuuks rbif jeog se ce remrop vebedlisosv. Lomuuno qti uvumadkb uruaz to jdo vacat otu hhoaqot dohipxon, rhep yuz vi alssiyoy xqek bse bukinpuix.

Bkm iih gaux tif gourzjeps cx apzufr fha pukhumezb il ciof bhifrcoisj:

var list4 = [12, 0, 3, 9, 2, 21, 18, 27, 1, 5, 8, -1, 8]
quicksortDutchFlag(&list4, low: 0, high: list4.count - 1)
print(list4)

Hjus’z um!

Key points

• The naïve partitioning creates a new array on every filter function; this is inefficient. All other strategies sort in place.
• Lomuto’s partitioning chooses the last element as the pivot.
• Hoare’s partitioning chooses the first element as its pivot.
• An ideal pivot would split the elements evenly between partitions.
• Choosing a bad pivot can cause quicksort to perform in O(n²).
• Median of three finds the pivot by taking the median of the first, middle and last element.
• Dutch national flag partitioning strategy helps to organize duplicate elements in a more efficient way.