Vad har vi pratat om i kursen?

Transkript

1 Vad har vi pratat om i kursen? Föreläsning 1 & 2 Systemminnet och systemstacken Rekursion Abstrakta datatyper Föreläsning 3 ADT:n Länkad lista Föreläsning 4 ADT:n Kö ADT:n Stack Föreläsning 5 Komplexitet Föreläsning 6 & 7 ADT:n Binärt träd Föreläsning 8 Sökning Föreläsning 9 Sortering Föreläsning 10 Sekventiell sökning Binärsökning Hashtabeller Binära sökträd Bubblesort Insertionsort Selectionsort Mergesort Quicksort Grafer

2 Vad har vi pratat om i kursen? Föreläsning 1 & 2 Systemminnet och systemstacken Rekursion Abstrakta datatyper Föreläsning 3 ADT:n Länkad lista Föreläsning 4 ADT:n Kö ADT:n Stack Föreläsning 5 Komplexitet Föreläsning 6 & 7 ADT:n Binärt träd Föreläsning 8 Sökning Föreläsning 9 Sortering Föreläsning 10 Sekventiell sökning Binärsökning Hashtabeller Binära sökträd Bubblesort Insertionsort Selectionsort Mergesort Quicksort Grafer

3 Minne När man startar ett program läggs det i datorns minne Data ligger åtskilt från programkoden i minnet Programkoden är konstant genom hela exekveringen Data kommer däremot att ändra sig under körning: När beräkningar utförs läggs resultatet i någon del av dataminnet Vartefter körningen fortgår kommer nya dataplatser att behövas vissa dataplatser är färdiganvända och behövs inte mer

4 Minne: referenser Kopiering: Anropsdata kopieras till parametrarna Referenser: Anropsdata kopieras inte. Istället blir parametrarna pekare (referenser) till anropsdata. Fördelar med referenser: CPU-krävande kopiering undviks Viktigt då data är stort Den anropade funktionen kan ändra på anroparens data Detta gör att man t.ex. kan returnera flera värden Nackdel med referenser: Programmeraren måste förstå skillnaden till kopiering

5 Rekursion När en funktion exekverar ligger dess variabler alltid överst på stacken Om en funktion anropar sig själv kommer en ny uppsättning variabler att läggas till på stacken Funktioner som anropar sig själva kallas rekursiva Rekursiva definitioner karaktäriseras av: Det måste finnas (minst) ett basfall Det måste finnas (minst) ett rekursivt fall Man särskiljer fallen genom något villkor Det rekursiva fallet måste ändra förutsättningarna för villkoret Basfallet innehåller inte rekursion Det rekursiva fallet innehåller rekursion

6 Rekursion Anrop: Fakultet(4) main Return 24 Rekursiv funktion: Fakultet(n) If n = 1 then Return 1 Return n*fakultet(n-1) Fakultet(4) Fakultet(3) Fakultet(2) Fakultet Fakultet Return 6 Return 2 Fakultet Return 1 Fakultet(1) Fakultet

7 ADT - Abstrakt DataTyp En definition av datats karaktär och De operationer som är möjliga på datat

8 ADT - Syfte Kortfattat: Att hålla isär Interface Implementation Användning Syftet är att underlätta konstruktion, återanvändning, testning, felsökning, läsbarhet. Genom att på detta sätt kapsla in implementationsdetaljer kan man undvika onödiga bindningar. Underlättar modifiering och vidareutveckling.

9 ADT ADT:n består av Ett interface och En implementation Genom att hålla isär dessa kan man vid behov ändra i implementationen. Så länge interfacet är detsamma så kommer de delar av programmet som använder ADT:n inte att påverkas.

10 ADT ADT:ns interface utgörs av allt som behövs för att kunna använda den, vanligen Ett namn på ADT:n Operationerna (med namn, indata och returdata). ADT:ns implementation är helt enkelt realiseringen av ADT:n En konkret beskrivning av hur data ska lagras och vilka typer de olika delarna har etc. Algoritmerna som behövs för respektive operation

11 Exempel: ADT:n RAT rationellt tal Rationella tal är detsamma som bråktal, t.ex. 7 3 eller 8 2 Talen över och under bråkstrecket är alltid hela tal.

12 ADT:n RAT rationellt tal De operationer som kan vara rimliga är t.ex de 4 räknesätten: Interfacet Funktion för att multiplicera två rationella tal. Returnerar produkten av dem: RAT muliply(rat r1, RAT r2) Funktion för att addera två rationella tal. Returnerar summan av dem: RAT add(rat r1, RAT r2)... etc.

13 ADT:n RAT rationellt tal Implementation, datalagring Eftersom rationella tal består av två heltal, täljare och nämnare så behövs bara ett par av heltal för att lagra det: <i 1, i 2 >

14 ADT:n RAT rationellt tal Implementation, multiplikation Algoritmen för att multiplicera två rationella tal är ganska rättfram: Vi vet att t.ex = 35 6 Dvs vi beräknar produkten av <i 1, i 2 > och <i 3, i 4 > som <i 1 * i 3, i 2 * i 4 >

15 ADT:er I litteraturen exemplifieras ADT:er ofta med t.ex. stack, kö, lista, träd. Men ADT konceptet är inte begränsat till sådana generella tillämpningar Man kan i princip betrakta vilken domän som helst som en ADT. T.ex. Ett schackbräde i ett schackspel Fiendeskepp i ett rymdfight-spel Person i ett personregister etc.

16 ADT:er För varje operation (dvs funktion eller metod) i en ADT anges Pre-condition: vilka krav på datat finns innan anropet. Post-condition: vad gäller för datat efter anropet. Vad som gäller för ett eventuellt returvärde. Ibland behöver man också beskriva med en lite längre text vad som utförs men aldrig hur det görs. Varför?

17 ADT - Allmänt Börja med att bestämma interfacet. Namn på ADT:n? Vilket data ska ADT:n ha? Vilka operationer vill vi kunna utföra på datat? Inparametrar? Returvärden? Preconditions? Postconditions? När vi vet detta börjar vi fundera på implementationen. Hur ska vi lagra datat? Hur ser algoritmerna ut för operationerna? Och hur implementerar vi detta?

18 Vad har vi pratat om i kursen? Föreläsning 1 & 2 Systemminnet och systemstacken Rekursion Abstrakta datatyper Föreläsning 3 ADT:n Länkad lista Föreläsning 4 ADT:n Kö ADT:n Stack Föreläsning 5 Komplexitet Föreläsning 6 & 7 ADT:n Binärt träd Föreläsning 8 Sökning Föreläsning 9 Sortering Föreläsning 10 Sekventiell sökning Binärsökning Hashtabeller Binära sökträd Bubblesort Insertionsort Selectionsort Mergesort Quicksort Grafer

19 Två typer av listor Länkad lista (eller bara lista ) Array ofta kallad vector eller fält Länkad lista är att föredra om insättning eller borttagning av element ofta behövs annat än i slutet Array är att föredra då direktaccess av godtyckliga element behövs ofta (med indexering) Om ingetdera gäller så är troligen array bäst Om båda gäller: gör ett klokt beslut!

20 Länkade listor, exempel En enkellänkad lista med 3 element: En nod Stoppmarkering i den sista nodens nextpekare head Det blå är elementet (själva datat) Pekare från en nod till nästa

21 Operationer på en länkad lista Lägga till en nod Först, sist, före, efter, på position... Ta bort en nod Först, sist, före, efter, på position Leta efter en nod i listan Skriva ut hela listan Räkna antalet noder i listan Slå ihop två listor etc...

22 Insättning i icke-tom lista Skapa en nod och sätt in datat (som tidigare) Skaffa en iterator Sätt den att peka på första noden Nu når vi till nästa nod via pilarna, ta den istället Upprepa tills det inte finns någon mer nod Nu kan vi sätt den hittills sista noden att peka på den nya noden

23 Insättning För att utföra insättningen itererade vi igenom alla elementen Detta är ineffektivt massor av bortkastad procesorkraft vid stora datamängder Vi kan lösas samma problem mer effektivt genom att implementera vår lista lite smartare! Hur? - Se till att listan har koll på både det första och sista elementet!

24 Remove Att ta bort ett element från någon plats Hur få tag på en iterator in till rätt nod? RemoveElement( ); Vi behöver pekare till denna nod...hur?

25 Mitt och ditt Vid användningen kan (och vill) man inte peta på listans implementation bara själva dataelementen som man lägger in i listan. Användning av ADT ADT interface ADT implementation

26 Mitt och ditt I listimplementationen kan (och vill) man hantera alla detaljer som har med själva listan att göra men inte användarens saker. Användning av ADT ADT interface ADT implementation

27 Olika typer av länkade listor Enkel länkad lista Dubbel länkad lista Pekare till första noden Pekare till både första och sista noden

28 Dubbel länkad lista Som en enkel länkad lista fast åt båda hållen. Ett data Två länkar (framåt och bakåt) Fördelar och nackdelar? Lika enkelt att iterera åt båda hållen Enklare att jobba med listan Mycket effektivare vid borttagning av nod Fler operationer för att tilldela data till en ny nod vid insättning

29 Vad har vi pratat om i kursen? Föreläsning 1 & 2 Systemminnet och systemstacken Rekursion Abstrakta datatyper Föreläsning 3 ADT:n Länkad lista Föreläsning 4 ADT:n Kö ADT:n Stack Föreläsning 5 Komplexitet Föreläsning 6 & 7 ADT:n Binärt träd Föreläsning 8 Sökning Föreläsning 9 Sortering Föreläsning 10 Sekventiell sökning Binärsökning Hashtabeller Binära sökträd Bubblesort Insertionsort Selectionsort Mergesort Quicksort Grafer

30 ADT:n Stack Stack är ett sätt att hantera data på enligt ett visst mönster Tänk på en stack som en hög tallrikar: Du kan bara plocka bort översta, och bara lägga dit en tallrik överst

31 ADT:en Stack Lägga data överst på stacken kallas Push Plocka bort datat överst på stacken kallas Pop Titta på översta datat kallas Peek Man kan fråga hur många element det finns på en stack med StackSize Kan en stack bli full? Teoretiskt, nej, men det beror på implementationen. En stack kallas ibland för en LIFO kö (Last In First Out)

32 Kan implementeras som en array 30 top Kan implementeras som en länkad lista 30 top //head Lägg till och ta bort vid top

33 ADT:n kö En kö består liksom en lista av en ordnad sekvens av element. Skillnaden är att i en kö stoppar man in elementen i ena änden och plockar ut dem i andra änden. Vanliga exempel är förstås sådana köer som man ibland måste stå och vänta i såsom bagageincheckning bankärenden butikskassa Etc. Finns olika typer av köer. Vi har tittat på FIFO köer. FIFO står för First In First Out, dvs en sådan vanlig kö som du har bekantat dig med på t.ex. Arlanda Detta köelement sätts in sist Detta köelement sattes in först

34 ADT:n kö Precis som en stack (och för den delen en lista) kan en kö realiseras genom en array. Fix längd => Array Dynamisk => Länkad lista Varför? Eftersom all access sker i ändarna (man behöver aldrig accessa ett visst index) så är man garanterad att länkade listan har fördel. Ibland vet man helt säkert att en kö inte kan bli längre än ett visst antal element. Detta kan sannolikt sammanträffa med begränsade resurser (t.ex. små inbyggda system) Array är då att föredra

35 Implementerad som array Start Front End Rear Lägg till vid Start Implementerad som länkad lista Ta bort vid End Start Front Head End Rear Foot

36 Cirkulär kö (arrayimplementation) En cirkulär kö är en kö av fix längd där start och front pekarna snurrar Beteendet uppnås med hjälp av modulus-operatorn. Start Front End Rear

37 Vad har vi pratat om i kursen? Föreläsning 1 & 2 Systemminnet och systemstacken Rekursion Abstrakta datatyper Föreläsning 3 ADT:n Länkad lista Föreläsning 4 ADT:n Kö ADT:n Stack Föreläsning 5 Komplexitet Föreläsning 6 & 7 ADT:n Binärt träd Föreläsning 8 Sökning Föreläsning 9 Sortering Föreläsning 10 Sekventiell sökning Binärsökning Hashtabeller Binära sökträd Bubblesort Insertionsort Selectionsort Mergesort Quicksort Grafer

38 Om t.ex. två algoritmer som löser samma problem ska jämföras eller vi vill ha en grov uppfattning om en algoritms komplexitet och mängden data kan vara stor används stora ordo, O(x) för att ge en grov bild av komplexiteten. Komplexiteten för en algoritm är det antal distinkta steg den kan behöva för att slutföra en beräkning. Komplexitet uttrycks som en funktion av datamängden n. O-notation beskriver prestanda och komplexitet Kan beskriva exekveringstid eller minne n är mängden data som algoritmen behandlar O-notation beskriver värsta möjliga scenario

39 De mest använda komplexitetsklasserna NAMN O-NOTATION Konstant O(1) Logaritmisk O(log n) Linjär O(n) n log n O(n log n) Kvadratisk O(n 2 ) Kubisk O(n 3 ) Exponentiell O(2 n ) Exponentiell O(10 n )

40 Om körtiden för en algoritm inte alls påverkas av antalet element säger man att den är konstant eller O(1) Om körtiden för en algoritm påverkas linjärt av antalet element säger man att den är linljär eller O(n), där n är antalet element. Om körtiden för en algoritm påverkas kvadratiskt (två nästlade loopar) av antalet element säger man att den är kvadratisk eller O(n 2 ), där n är antalet element. Att nollställa en matris är O(m*n) där m är antalet rader och n är antalet kolumner. Då datamängden hela tiden halveras (t.ex. sökning i binärt sökträd) är komplexiteten Logaritmisk eller O(n log n), där n är antalet element. etc.

41 Enkla regler Det är bara loopar vars antal iterationer som är beroende av indatats storlek som man behöver ta hänsyn till. Nästlingen avgör vilket O() det blir Nästlade loopar multipliceras Sekventiella loopar adderas Man måste titta i alla funktioner som anropas. Om två loopar är nästlade på samma nivå i loophiearkin så är det den av looparna som kan iterera flest gånger som man räknar med. Bara den största (mest dominanta) termen behålls, resten skippas.

42 Vad har vi pratat om i kursen? Föreläsning 1 & 2 Systemminnet och systemstacken Rekursion Abstrakta datatyper Föreläsning 3 ADT:n Länkad lista Föreläsning 4 ADT:n Kö ADT:n Stack Föreläsning 5 Komplexitet Föreläsning 6 & 7 ADT:n Binärt träd Föreläsning 8 Sökning Föreläsning 9 Sortering Föreläsning 10 Sekventiell sökning Binärsökning Hashtabeller Binära sökträd Bubblesort Insertionsort Selectionsort Mergesort Quicksort Grafer

43 Träd Rot Förgrening Löv

44 Datastrukturen Träd Träd är icke-linjära datastrukturer som ofta används för att beskriva hierarkier Fönster på skärmen Widgets i fönstren Släktträd Etc. Ett träd är en samling element som sparas i noder, vilka är sammankopplade i en trädstruktur. Toppen på trädet kallas rot och varje träd (delträd) har en ensam rot.

45 Binära träd En speciell kategori av träd Varje förgrening går till högst två noder Lite enklare då det är en specialisering Vi fokuserade på binära träd i kursen

46 ADT:n Binärt träd Vår binära trädnod håller: - data - pekare till två nya noder data pekare pekare

47 Några begrepp Rutorna kallas noder (nodes), de innehåller något slags data som är av intresse för användningen Direkt under en nod finns högst två noder, barn (child, kid). Specifikt: Left child, right child. Alla noder utom en (rotnoden) har exakt en nod över sig, dess förälder (parent) rot (root) har inte någon annan nod över sig Anfäder (ancestors) till en nod: alla noder som kan nås genom att följa linjerna uppåt Ättlingar (descendants) till en nod: alla noder som kan nås genom att följa linjerna nedåt En nod som saknar barn är ett löv (leaf) Skog (forest): en mängd av träd Trädhöjd eller träddjup

48 Delträd E Delträd under rot noden Delträd under noden E

49 Definition Följande rekursiva definition gäller för binärt träd: Ingen nod är ett binärt träd (ett tomt binärt träd) En nod med två barnträd, ett vänster barnträd och ett höger barnträd, är ett binärt träd

50 ADT:ns operationer Sätta in en ny nod till vänster/höger Skapa nytt träd av två delträd (bind ihop dem med en ny nod) Ta bort vänster/höger barnträd Tala om vilket antal noder trädet har Tala om höjden (djupet) på trädet Svara på om en nod är löv resp. rot Returnera data Returnera vänster/höger barnnod Ta bort godtycklig nod (mer om detta senare) Traversera trädet

51 InsertSorted Att lägga till i ett binärt träd görs oftast sorterat. Om den nya nodens data är mindre än rotens data gå åt vänster Om den nya nodens data är större än rotens data gå åt höger Gör detta för varje delträd! Om trädet är sorterat kan vi använda den informationen även när vi ska söka efter data i trädet.

52 Traversering De metoder som brukar användas kallas Preorder: behandla data före besök av barnträden Inorder: behandla data mellan besöken av barnträden Postorder: behandla data efter att barnträden besökts

53 Remove Ta bort godtycklig nod från det sorterade binära trädet. Tre fall Ta bort löv Ta bort nod med ett höger ELLER vänsterbarn Ta bort en nod med ett höger OCH ett vänsterbarn Trädet ska fortfarande vara sorterat efter borttagningen

54 Ta bort löv Leta reda på noden som ska tas bort Se till att nå dess förälder på något sätt Sätt förälderns pekare till null Vi måste här veta vilken av förälderns pekare som ska sättas till null Lövet är borttaget

55 Ta bort nod med ett barn Nu är det fyra saker vi måste testa Nodens barn kan vara ett vänsterbarn Nodens barn kan vara ett högerbarn Noden som ska tas bort kan vara ett vänsterbarn Noden som ska tas bort kan vara ett högerbarn

56 Ta bort nod med ett barn Om noden har ett vänsterbarn Om noden är ett vänsterbarn Förälderns vänsterpekare ska peka på nodens vänsterbarn Annars (om noden är ett högerbarn) Förälderns högerpekare ska peka på nodens vänsterbarn Annars (om noden har ett högerbarn) Om noden är ett vänsterbarn Förälderns vänsterpekare ska peka på nodens högerbarn Annars (om noden är ett högerbarn) Förälderns högerpekare ska peka på nodens högerbarn

57 Ta bort nod med två barn Hitta det minsta värdet i höger delträd eller Det största värdet i vänster delträd Kopiera detta värde till den nod som ska tas bort Ta bort den nod som kopierades (antingen ett löv eller en nod med ett barn här kanske man kan göra ett rekursivt anrop?)

58 Att traversera från roten till en godtycklig nod i ett fullt träd är väsentligt effektivare än att ta sig till en godtycklig nod i en lista. N lg N Traversera i lista = O(n) Traversera i sorterat binärt träd = O(lg n) Värsta fallet för en lista är sista noden. Värsta fallet för ett binärt träd är ett löv i trädet.

59 Vad har vi pratat om i kursen? Föreläsning 1 & 2 Systemminnet och systemstacken Rekursion Abstrakta datatyper Föreläsning 3 ADT:n Länkad lista Föreläsning 4 ADT:n Kö ADT:n Stack Föreläsning 5 Komplexitet Föreläsning 6 & 7 ADT:n Binärt träd Föreläsning 8 Sökning Föreläsning 9 Sortering Föreläsning 10 Sekventiell sökning Binärsökning Hashtabeller Balanserade sökträd Bubblesort Insertionsort Selectionsort Mergesort Quicksort Grafer

60 Linjär sökning Linjär sökning eller sekventiell sökning innebär att man tittar på alla element i ordning tills dess att man har hittat det eftersökta datat eller tills arrayen är slut. Det spelar ingen roll om arrayen är sorterad eller inte. Enkel insättning (sist)

61 Binärsökning Om arrayen är sorterad kan en klokare algoritm användas. Binärsökning går till så att: Först kollar vi elementet I mitten. Om det har en efterfrågade nyckel så är vi klara. Om inte Om den efterfrågade nyckeln är mindre än mitten elementet så utför vi binärsökning på vänster delarray. Annars utför vi binärsökning på höger delarray. Exampel: SEARCH(4) Steg 1 Steg 2: binärsökning i högra halvan Steg 3: binärsökning i vänstra halva (av högra halvan)

62 Ambition: Kombinera fördelarna med Hashtabeller Direktadressering: Operationer med O(1) tidskomplexitet Sorterad array: Platsbehovet O(N) där N är antalet element Hashtabeller går ut på att istället för att använda nyckeln som ett index direkt, utföra någon form av beräkning med nyckeln som input och ett index som output. Hash-indexet, eller hash-nyckeln, måste ligga i det intervall av index som finns i tabellens array. Funktionen som skapar en hash-nyckel från en nyckel kallas hash-funktion, h: U { 0, 1,, M-1} där M är antalet element, och U är mängden av alla möjliga nycklar. Vanligen väljer man M > U (om U är känt). I allmänhet är det inte möjligt att hitta garanterat unika hash-nycklar ofta vet man inte heller exakt vilka nycklar som kommer att uppträda, bara att de är för stora för direktadressering. Tricket med hashtabeller är att man accepterar att hash-nycklar kan krocka och har någon hantering av detta, så att problem inte uppstår

63 Hashtabeller För att garantera att hash-nyckeln hamnar inom arrayens tillåtna index, användas key modulus M, där key är elementets nyckel och M är antalet platser. Indexen kommer då alltid att bli 0...(M-1) Med nycklarna från tidigare exempel { 0, 2, 120, 121, , } och en arrastorlek på 10, skulle vi få hashnycklarna { 0, 2, 0, 1, 2, 3} Den enklaste formen av hashfunktion utför bara modulusoperationen Som vi ser här blir det krock mellan nycklarna 0 och 120 respektive 2 och Det finns flera varianter av beräkningar som hashfunktionen kan göra på en nyckel innan modulusoperationen appliceras, med syfte att minska risken för krock den kan normalt sett aldrig elimineras helt

64 Hashtabeller Några metoder för att lösa krockproblemet Öppen adressering Lista ("chaining")

65 Hashtabeller Öppen adressering linjär koll efter ledig Om ett index är upptaget letar vi framåt tills vi hittar ett ledigt Exempel: 12 mod 13 = 12 1 mod 13 = 1 54 mod 13 = 2 40 mod 13 = NIL NIL NIL 6 NIL 7 NIL 8 NIL 9 NIL 10 NIL 11 NIL 12 12

66 Hashtabeller "Chained" Hashtabellen utgör en array av länkade listor: 0 Exempel: 12 mod 13 = 12 1 mod 13 = mod 13 = mod 13 =

67 Hashtabeller Fördelen med chained är Nackdel Tabellen kan aldrig bli full En krock leder inte till att sannolikheten för krock ökar för andra hashnycklar Det går åt lite mer minne (betydelselöst)

68 Hashtabeller För att minska risken för krock (oavsett vald metod för att lösa krockar): Välj en bra storlek på tabellen: storlek som är ett primtal storlek om minst ca 1.3 gånger antalet element problem: man vet inte alltid antalet element på förhand att ändra storleken då det redan finns element på plats leder till att man inte längre hittar rätt element (pga mod): tabellen måste byggas om Välj bra hashfunktion Alla bitar involveras i beräkningen

69 Balanserade sökträd Definition: Binärt sökträd (BST) är en datastruktur i form av ett binärt träd med följande egenskaper: varje nod (elementets nyckel) has a value; en total ordning (linär ordning) är definierad på dessa värden > Det vänstra subträdet till en nod innehåller bara värden mindre än eller lika denna nods värde Det högra subträdet av noden innehåller bara värden större än denna nods värde

70 Vad har vi pratat om i kursen? Föreläsning 1 & 2 Systemminnet och systemstacken Rekursion Abstrakta datatyper Föreläsning 3 ADT:n Länkad lista Föreläsning 4 ADT:n Kö ADT:n Stack Föreläsning 5 Komplexitet Föreläsning 6 & 7 ADT:n Binärt träd Föreläsning 8 Sökning Föreläsning 9 Sortering Föreläsning 10 Sekventiell sökning Binärsökning Hashtabeller Binära sökträd Bubblesort Insertionsort Selectionsort Mergesort Quicksort Grafer

71 Klassificering Man kan särskilja tre huvudmetoder för att sortera data (illustrerad med en tänkt kortlek): Byten, "swapping" Lägg korthögen på bordet. Dra två intilliggande kort och lägg tillbaks dem på samma plats men i inbördes rätt ordning. Fortsätt tills hela högen är sorterad. Urvalssortering "selection sort" Lägg korthögen på bordet. Leta upp det minsta kortet och behåll det i handen. Leta upp det kort som nu är det minsta och sätt det under det du senast tog. Fortsätt tills högen är tom. Insättningssortering "insertion sort" Lägg korthögen på bordet. Ta det översta kortet från högen och behåll det i handen. Ta det kort som nu är överst och sätt det på sin rätta plats bland de kort som du har i handen. Fortsätt tills högen är tom.

72 Bubbelsortering Algoritmen Vi börjar med att angripa problemet med bubbelsortering. Det uppfattas ofta som enkelt att inse att algoritmen verkligen sorterar elementen. Dessutom är den också förhållandevis enkel att programmera. Den är dock mest av akademiskt intresse, då den inte är så effektiv (den används sannolikt aldrig annat än som introduktionsexempel på denna typ av kurser). Grunden i algoritmen är att jämföra två element som ligger intill varandra och byta plats på dem om den inbördes ordningen är fel. Sen gäller det bara att upprepa detta tillräckligt många gånger för alla element för att man ska vara övertygad om att hela mängden av element är sorterad.

73 Bubbelsortering Förbättringar man kan göra Man kan minska antalet element som jämförs med ett varje varv. Man kan avsluta algoritmen om inget byta gjorts på ett helt varv Man kan jobba från två håll

74 Insättningssortering Vi tänker oss att arrayen består av 2 delar, V (som alltid är sorterad) och H (som alltid är osorterad). Från början innehåller V ett element (det första ett element är per definition färdigsorterat utan att man behöver göra något). Resten av elementen finns i H. I varje runda krymper H med ett element och V utökas med ett element. Det är alltid det första elementet som tas från H, och detta sätts in på rätt plats i V.

75 Selektionssortering Denna algoritm beter sig i någon mening omvänt mot Insättningssorteringen. Betrakta återigen arrayen som två delar V och H (vänster och höger) V är initialt tom, alla element ligger i H Leta upp det minsta elementet i H. Byt detta med det första i H Flytta fram gränsen mellan V och H. Upprepa tills H har bara ett element

76 Härska genom att söndra Mergesort och quicksort skiljer sig från bubblesort, insertionsort och selectionsort I stället för det inkrementella angreppssättet... t.ex.: InsertionSort: när den partiella arrayen, A[0..j-1] är sorterad så tar man itu med elementet A[j]... så använder de "härska genom att söndra"-paradigmen "Söndra" (dela ner) problemet i ett antal delproblem "Härska" (ta kontrollen över) delproblemen rekursivt så länge de är "stora" direkt om de är tillräckligt små Kombinera alla lösningar till delproblemen för att få en lösning till hela problemet

77 Mergesort Merge (="blanda") avser i detta fall att sätta samman två eller fler redan sorterade sekvenser, på ett sådant sätt att även den nya är sorterad. Exempel: (10, 23, 36, 42) (4, 6, 54, 64) (4, 6, 10, 23, 36, 42, 54, 64) Det är trivialt att sekvenser av längden 1 är sorterade. Sådana kan lätt kombineras ihop för att bilda sekveser som är 2 långa, som kan kombineras ihop till sekvenser av längd 4, etc. Mergesort följer "härska genom att söndra"-paradigmen ("divide and conquer"): Divide: Dela upp en Array A av längden N i två delarrayer A1 och A 2 var och en av längden N/2 Conquer: Sortera delarrayerna rekursivt genom att applicera Mergesort (med basvillkor som baserar sig på att en delarray av längden 1 är sorterad per definition) Combine: "Merga" de sorterade delarrayerna till en sorterad array

78 Quicksort Quicksort baserar sig på byten (liksom bubbelsortering) kombinerat med "divide and conquer" (likt mergesort). En sekvens, S, sorteras enligt Divide: Välj ett element x (kallat pivot) och partitionera S till X - L element mindre än x - E element lika med x - G element större än x X Conquer: Sortera L och G genom rekursion L E G X Combine: Behövs inte, eftersom L, E och G redan ligger i samma array.