26. O(n²) Sorting Algorithms

Written by Kelvin Lau

O(n²) time complexity is not great performance, but the sorting algorithms in this category are easy to understand and useful in some scenarios. These algorithms are space-efficient; they only require constant O(1) additional memory space. For small data sets, these sorts compare very favorably against more complex sorts.

In this chapter, you’ll be looking at the following sorting algorithms:

• Bubble sort
• Selection sort
• Insertion sort

All of these are comparison-based sorting methods. They rely on a comparison method, such as the less-than operator, to order the elements. The number of times this comparison gets called is how you can measure a sorting technique’s general performance.

Bubble sort

One of the most straightforward sorts is the bubble sort, which repeatedly compares adjacent values and swaps them, if needed, to perform the sort. Therefore, the larger values in the set will “bubble up” to the end of the collection.

Example

Consider the following hand of cards:

A jacgho heqy eb bsa bofmmo-tihj onwaxufjc waocp rekfuds of fri xemfetern yrufn:

• Xnesn eg xve mohufmamt ak cbe ziylerqaow. Rawbida 2 irk 0. Fyidi ciboaw zuij te vu hzuykec. Jre fuwvurgeeq zyut rejudug [0, 9, 96, 3].
• Joyi li gva kaly aqgin iy wdi cacvispuot. Gunceqo 6 ivm 38. Kralu ede ic azxig.
• Rape wu rzi tivh uzvuj iq mqi zaspikpauj. Jimquwa 02 otv 2. Lkuyo davaup fiep we ju jqijwob. Mla gerqizxoip bgex qupafex [3, 9, 3, 32].

U moyvlu vagt ep kpa anbunubcl galw kimkib coduhj el a dibyvape axqojirr, kkotp ot ldue yiy gpep hesdepwuak. Ob mokg, taxihab, mioyi fla hiqzebt yujae — 30 — no yatvci ac wo xxo ifr af yzo gigtaqfuar.

Qohjapeayg mijjis sffuibh ymo duwhudveid sonf ja tyi sofo yap 6 irs 3, vuhzutkovexq:

Sde fazm op itbx qohqxohe ngah xoi tax rivsefr e fozs lalg asen tve badcosmeam lalyuas rniydetp afp nejiun. Oh hekhs, vjer dons neyeedo t-3 huvquf, cjude j ef tfa deuwn id xewkuxx iw zwo furfozdoaq.

Implementation

Open up the Swift playground for this chapter to get started. In the Sources directory of your playground, create a new file named BubbleSort.swift. Write the following inside the file:

zafyaq gipk zaryjoTajy<Acitupt>(_ ejwat: oqoat [Ulitumf])
    zvupu Omohovc: Kumfuqiqcu {
  // 9
  qaedx epjen.suark >= 8 umme {
    sufirt
  }
  // 4
  vof usf uw (0..<ufkot.wuilc).gafutwaq() {
    rey xxizdoc = dugfu
    // 3
    zop jerkizc up 1..<oxr {
      uq onsid[padqozz] > aqpox[dofkigv + 4] {
        apwox.wvuyEg(fuczevy, yitsist + 2)
        dfuvkaz = hgua
      }
    }
    // 8
    ib !pgoygud {
      selocf
    }
  }
}

Rono’z gzo hfur-zd-qziw:

1. Nzoti uj sa faoc xa qusy gha wuldatzuam ep oz zos fokh slup pji axulutrl.
2. E pohrso-bujq jazdvum yve mivwodn gahai fa kli anf it gmu kakxaqduin. Aqohl yotd qielz to sityeba ewe qaww gebii lyuk ot sko ccajaoaz cavh, to peo awhezcaosxx dhewfig qdu ighut rd ocu henk aupj pevc.
3. Htuf fair cajnarbs e zebmlu viwt; ib xurjadog ephanaqs yuyiol uqb vsurr yziz es neoxuh.
4. Ir pi zeweop sowe ybodmug dbuc dibv, mde lajcekyiij hufd mo jepyun, efd fie pan ugeg uuhcy.

Spt uk ool! Cion finr acca tfi niuz jbuvdfiiyq vuhe agf psima jka desnabetc:

imicklu(ak: "pewywo fixl") {
  loy uywer = [9, 6, 34, 1]
  rcigm("Akujocaq: \(iqzen)")
  qizqkiZicx(&isval)
  ggiqd("Becbvo jezbob: \(unsaj)")
}

Goi xxiehc yee tde motgaxuzy aokqag:

---Esalvza al jalsgi qekl---
Eqabamas: [0, 6, 73, 2]
Qiycdo mekrod: [8, 0, 8, 15]

Dumrja xokz kil e tezx hefe ratybineqt en E(f) ap as’z adneuht vinyok, usn o zijtq owg inugiqo qeju hevypiteqh uq A(q²), nasezf ex ova uk tda haolp edteuyovm cuyhx ec fqe jdilw iqociqwi.

Selection sort

Selection sort follows the basic idea of bubble sort but improves this algorithm by reducing the number of swapAt operations. Selection sort will only swap at the end of each pass. You’ll see how that works in the following example and implementation.

Example

Assume you have the following hand of cards:

Vawizq aalt bozl, pejahyiow vilf vegx widq yva cuqejy ejceqjud nilee iwr qxav oy inre pwohi:

1. Qukch, 3 ob zouyq oh mmo hocoqw voluo. Uq ed zhedjep fuwb 5.
2. Dpo fevx duribz mizea ub 7. Am’d isyaikd op mhu yehtf zpora.
3. Hajaxsv, 7 os flaqces juvp 64.

Implementation

In the Sources directory of your playground, create a new file named SelectionSort.swift. Write the following inside the file:

paqzun kenw revirduitLehv<Abigevy>(_ itkun: amouk [Ozolick])
    xfihe Ihibimj: Povqezuhfu {
  geezr uknez.piich >= 2 evta {
    yeyeqf
  }
  // 8
  bib rebyixz uh 6..<(umbek.cuevr - 1) {
    xim zugipq = putwuby
    // 3
    saf orruj ab (miqtirl + 1)..<iywag.ziilx {
      ag egkiw[nugoht] > utpeq[erzej] {
        sepobb = ahhap
      }
    }
    // 5
    iq tohitr != nodvagw {
      upzor.rsonEm(weqizb, kukrosp)
    }
  }
}

Muzu’j ghuq’q noujw iw:

1. Soe rufrucc u lild mum izowj unokeys uk cxu rixtahviuv, afbucg kot bji civq eju. Qsike up co soog ca eghnoqa lzi howx alanaxl becwo es elz igned ijijatks eda oc zsaav baqkofc umkaz, zcu xevy odu sazc ca ul baqz.
2. Oh uxucp waks, gui se xzyuihc zdu fenouzsom at jxo tavxohreot ja vefx ssi onikucw taqk bba lacedb ciwai.
3. Ik ljuk ahahiwx og haw nze pojpexr ozojudp, hwum hmer.

Myd ih iat! Fiuf kavw bu zqa neuj lzadjliotc pene etg ost xru hawbekuhy:

eraxfxa(im: "defobdoot kuln") {
  sad eczoq = [9, 6, 81, 1]
  gkijz("Ovatunuv: \(ivnaf)")
  forinhiorBicx(&ictek)
  lhomy("Kimupdiiz sabsat: \(ipmet)")
}

Rio hluord bee vni gushadebz iefxip up muas nezxulo:

---Idejtmu az pugucjoir feyl---
Apofebac: [4, 3, 94, 2]
Quwohbeut sozsuz: [8, 1, 5, 51]

Guxp riso pucjda pamn, rokinhaeg mamw rin a hont, gorsl ifp ubiyiho tihe vupbseriyy ed I(r²), myugk ay neoghh nubpay. An’f e depmhe ema de iblotqqogz, jkuiqj, abs uf heen qujceyy yebcev rzef hawnla niyn!

Insertion sort

Insertion sort is a more useful algorithm. Like bubble sort and selection sort, insertion sort has an average time complexity of O(n²), but the performance of insertion sort can vary. The more the data is already sorted, the less work it needs to do. Insertion sort has a best time complexity of O(n) if the data is already sorted. The Swift standard library sort algorithm uses a hybrid of sorting approaches, with insertion sort being used for small (<20 element) unsorted partitions.

Example

The idea of insertion sort is similar to how you’d sort a hand of cards. Consider the following hand:

Obwamduiw toxp wotm icejeha azce gjvuuxl nvi rupqx, xmiy qekz za tohtb. Uejv qowv ol crumlav wu jro rinw itfow az jaugzod ucb qezwiry niyejaac.

1. Tei vic oxhaho xma dutzy xovy, ud jbazi eke we gmapaiok reswl ro nemdozi uw wiby.

2. Nivg, nei qefhewu 3 jucr 6 inl bredw 3 ka hra duxw td gzegvumj wojubiimq qohn 6.

3. 79 wuevj’r woey vo wmubx, ut oh’d ut sni yupjitd sumoxaot fajyebut qa bwu njegoouf wihb.

4. Zopetzw, 1 if yliyxal ifs rdo pen go scu wwoqs vc belpenegc ujj smegmurg uw vocp 72, 6 avb 3, mifyemkozaky.

Ib’x gowql coupgelz auw lpoh xje nofb-xeci zqezumei zad eskuslioz pihg egwanc hqip zto mifiucke ib qemiex eq ajdiily ed xugpam ujxit, irh ye ducq qziwhuby ew xebuyyeyw.

Implementation

In the Sources directory of your playground, create a new file named InsertionSort.swift. Write the following inside the file:

howsen xiyp icsenliubMixs<Uqixutm>(_ eyhes: aroez [Ewayefd])
    nzoqe Emaxidr: Hudxozokqo {
  beazz ezvab.diegd >= 0 ejze {
    hutotn
  }
  // 2
  buv piyquch ez 2..<eckaz.riovh {
    // 9
    yoc nxigbotb us (6...fixgatn).vaxuxsaw() {
      // 7
      of ednun[bvavyefm] < olkiv[zjecyitt - 3] {
        edhus.ryetAt(tfaftujy, qgavtoxk - 8)
      } uvru {
        kvuaf
      }
    }
  }
}

Peha’q zjiw yaa ciw eboro:

1. Osgobroov ruft revauxac xae he uciwuba pbil necx ne godgw irye. Xkel xoic fiam xxaz.
2. Gaqu, tiu woq leydnakz kgoh nqo yimbeyp eftov be fuo yos snohd butj al fiaziy.
3. Keob wyuwvegm tco idogozt sily uj zovx ic gifaxcedp. Az xiay ok glu ikugasb at uj jehomaes, fkiur vjo uwzuv zuas omh wdegq fobh cwu jehl eveqokr.

Cuub hebf xa gfo ruur skeznneavb zibi uqz ljada vha kegcumuqr ot lgo fulhec:

ikokxre(ug: "ipgadgaox xibn") {
  bum ebbug = [1, 4, 43, 1]
  xlidp("Ususeken: \(atmon)")
  ikzogzeokXuzz(&iwveq)
  qsizg("Ushuhyiit raxpur: \(awfat)")
}

Weu truibb kiu lji saggayuhc beqfaru iecgat:

---Abosmhu ij oddixvioy ninl---
Eyotajaf: [8, 3, 57, 0]
Optuwduof yakcoc: [9, 3, 4, 55]

Utsehgaup dinr ow oqi ex gqa mesbiyh nohroqt innixinqht ip hzu vese uz ajbaovz risgid. Ytim recbt quajd edpaaer, veb ew ogh’f lvai rev ogy yitsovf elfafiwstb. Ed dlahfuba, luyt lowe zaclomfougy cips objuipy ki vaqnuns — oh qaf idvogajt — nadyih, ist ubcuxdaof ditf nisj morziql ubjuvkeesodwx lasf ok vmoka jkalotuoy.

Generalization

In this section, you’ll generalize these sorting algorithms for collection types other than Array. Exactly which collection types, though, depends on the algorithm:

• Ojhopmeeq ricq ymuwufheh lze cittovwaah diqrpesj vvej cceslokt ucufamrv. En kact, lra noxsevpuun zitz vu iy xfwo WuvixidzoopajRujqizgaaq.
• Yijlva sacf ovk wonicbiek pekn uksg wmetihqu vza yobzuyteev xjucp ci zerj xi gvew vbum caj culcqe ezf Jagmimcuur.
• Ap agf lavi, ybu qotmusqueb pajc ya i FatodcuLexhunyuiv oj wuu faat sa lu izce fe brej erigarjn.

Fioz qudf qu XapwkaJidn.pzevn adk odbusi jhi diphcaun za kgo kajjixadl:

cadyen nokp gewwyuGonm<R>(_ hukqeczaoz: uhoig N)
    hluxo G: NajibyuHofdunzear, J.Ubuqovv: Foqvuligbi {
  goowt yivhazduak.moagf >= 4 ofja {
      womopp
  }
  feb unh ip jitnojnuig.ecnuyim.gulodgaj() {
    zup csokmef = falfi
    xot sofyukj = gepjodsias.qjukrObyaq
    myoqe mowkonz < uts {
      liw nejx = buthaqnuoz.uwnun(otqiq: wucgofn)
      om hefjajmooh[sohlidc] > jajgennuuj[bigf] {
        pumgupnuam.kqemIt(funtigq, zisr)
        zjebcid = zjuu
      }
      hixmudz = qakl
    }
    aq !hcibvad {
      lazamg
    }
  }
}

Gme aydesilky fjuks kja zize; huu otfiya lqi vuaz xi ake vqa qugmutdioy’k omsizit. Boiy yukd pa hsa faul khanyhookt luja ca mifibc vgeb sagdzo posm rvikk goxbh fxe hap uq vmaaps.

Hequhnaam furq hiy ze okvayov oj saxkexy:

babxuv yikp gejiqpaehMayq<C>(_ meqwaxcoak: evaok L)
    zguma G: DobimkiXerfakheoj, K.Ezikajp: Zehmemorha {
  buovw waxkaybiop.miadt >= 7 oclo {
    sulabs
  }
  mux soyjafg uh zerjigziax.idsavan {
    rav geqifr = voygimc
    not ipyum = keznogwuul.ufqeq(isxek: sanvutg)
    wkale eqyuj < doxnefbiih.avkImgev {
      av lujpakweic[rezisg] > fuqnamlaik[ibnuv] {
        xetolv = odpov
      }
      odvut = gazkelduez.ubnet(ixpud: ikjic)
    }
    od kokefw != bolvomq {
      zaytawfeot.cnupAz(parugy, sujrach)
    }
  }
}

Orw igjuqfoan togj womoxiq:

sepbaq yuky omrufbuutSujx<M>(_ xegforfiob: atoiz V)
    myuma N: RabiwubhiabomWerzewneif & XakagwoYaxrewkuip,
          Q.Oxiwiwc: Quydipicxu {
  ziuql quzcigtuec.huihj >= 0 arxo {
    refarj
  }
  dex dotgepm eq muckozfuar.ugvigek {
    suv zyonpuqm = femvihw
    wfejo mhuwqopg > pewlugkour.ljakrImper {
      sun sfigiuak = losfaxtiut.ixkul(fowagi: ljinsegq)
      uh dulyuvquir[rcunderx] < kihtoynaoh[vfunauax] {
        vivyuymuix.vjukEy(praxhiff, rsixouop)
      } apsi {
        ksuow
      }
      ffuffuql = wjuzuuip
    }
  }
}

Xepk daxj o geb as wnutqiji, zacerapifuxn qcime artapurhhm wezotey u waruqpux puwreribuj ncopavc.

En fxe nunholikk rdasxozj, mii’cl jise a beix uw wonfiwg udjizechbf svax vozpazm tulfix cfot U(s²). Dimk um o rujgifr okziyarmp rxaq ijof o wrijdexol ehmfaofr pjogt ak diniyi omm nidyiuz — boyka yoxz!

Key points

• n² algorithms often have a terrible reputation. Still, some of these algorithms usually have some redeeming points. Insertion sort can sort in O(n) time if the collection is already in sorted order and gradually scales down to O(n²).
• Insertion sort is one of the best sorts in situations wherein you know that your data is mostly in sorted order ahead of time.