Linjär sökning. Föreläsning 12. Binär sökning. Exempel: Binära sökträd. Binärt sökträd

Transkript

1 Föreläsning 2 Sökning, Sökträd och Sortering Linjär sökning Starta från början och sök tills elementet hittat eller sekvensen slut. Komplexitet Elementet finns: I medel gå igenom halva listan, O(n) Elementet saknas: I medel gå igenom hela listan, O(n) Om listan är sorterad: Elementet saknas: Räcker i medel att leta genom halva listan n/2, O(n) Binär sökning Om sekvensen har index (tex i en array eller numrerad lista) kan man söka binärt. Successiv halvering av sökintervallet. Vi får värsta-falls och medelkomplexitet O(log n). Jämför med elementet närmast mitten i intervallet. Om likhet klart! Om det sökta värdet kommer före i sorteringsordningen fortsätt sökningen rekursivt i det vänstra delintervallet. Om det kommer efter i sorteringsordningen fortsätt sökningen rekursivt i det högra delintervallet. Exempel: Sök efter elementet 3. Linjär sökning: 8 jämförelser innan träff. Binär sökning: 2 jämförelser innan träff. Sök efter elementet Linjär sökning: 8 jämförelser innan man ger upp. Binär sökning: 4 jämförelser innan man ger upp Binärt sökträd Används för sökning i linjära samlingar av dataobjekt, specifikt för att konstruera tabeller och lexikon. Organisation: Ett binärt träd som är sorterat med avseende på en sorteringsordning R av etikett-typen så att I varje nod N gäller att alla etiketter i vänster delträd går före N som i sin tur går före alla etiketter i höger delträd. Alla noder är definierade. Binära sökträd Om trädet är komplett så vet vi att både medel- och värstafallskomplexiteten är O (log n). Men Det tar tid och kraft att se till att trädet är komplett. Ibland kan man tvingas bygga om hela trädet. Det räcker att se till att balansen är god

2 Balanserade binära sökträd Finns flera olika metoder t.ex.: AVL träd Röd svarta träd (Red-black tree) B-träd Annan trädstruktur med balanseringsfunktionalitet. Flervägs sökträd Ett m-vägs sökträd (m-way search tree, m-ary search tree) är en generalisering av ett binärt sökträd. Trädet är ett ordnat träd där varje nod har högst m delträd. Etiketterna är sekvenser av upp till m- värden i stigande sorteringsordning som fungerar som delningspunkter vid sökning. Oftast är etiketterna nycklar och värdet till en viss nyckel finns i lövet Flervägs sökträd Till en nod med k+ delträd, t, t,, t k hör en sekvens med värden v, v 2,, v k. Sorteringsvillkoret för trädet är att: alla värden i t går före v (i sorteringsordningen) alla värden i t j ligger mellan v j och v j+ för <j<k alla värden i t k går efter v k Operationerna blir liknande de för binärt sökträd. Plattare träd. Höjden = log m n B-träd Ett B-träd av ordning m är en typ av balanserat m-vägs sökträd som uppfyller följande: Roten är antingen ett löv eller har minst två barn Alla noder utom roten och löven har mellan m/ 2 och m barn Alla löv är på samma djup Mer jobb i noderna B-träd Insättning av nya element görs alltid på den djupaste nivån, i rätt löv för att bevara sorteringsordningen. En insättning kan leda till att noden blir för stor (dvs > m). Då måste noden delas upp. Borttagning kan leda till att man måste justera värdena och slå ihop noder eller omfördela värden mellan dem. B-träd av ordning 3 kallas också 2-3 träd 36 B-träd analys: För ett B-träd av ordning m, med höjden h och n nycklar insatta gäller h = O(log n). För att välja rätt underträd vid sökning krävs att man stänger in sökt nyckel mellan två nycklar i noden. Om nycklarna är sorterade och lagrade i en vektor kan man använda binärsökning. Sökning i en nod O(log m) Nycklarna i vektorn måste skiftas runt vid splittring av en nod. Kostnad O(m) Eftersom m är en konstant blir det O() arbete i varje nod vid sökning och insättning. Antalet noder som berörs är uppåt begränsad av höjden. Värstafallskostnad för sökning och insättning O(log n) 362

3 Exempel på B-träd: 2-4 träd Varje nod har, 2 eller 3 nycklar och varje ickelöv har 2-4 barn. Regel för insättning: Man letar sig fram till rätt löv på liknande sätt som i ett vanligt sökträd. Den nya nyckeln sätts in där. Om det blir för många nycklar i det lövet splittras det och det mittersta värdet skickas upp till föräldern som en uppdelningspunkt (eller en ny rotnivå skapas om vi 363 var i rotnoden) Exempel på B-träd: 2-4 träd Regel för borttagning: Leta rätt på rätt nod. Om detta inte är en lövnod byt plats på denna nod och största i delträdet till vänster eller minsta i delträdet till höger. Man letar sig fram till rätt löv i noden, ta bort den som ska bort. Några olika fall kan uppstå vid borttagningen ur lövnoden Enkla fallet: Det finns flera nycklar i noden. Plocka bara bort Halvsvåra fallet: Syskonen har extra noder som vi kan förskjuta till vår nod. Svåra fallet: Vi får tomt och syskonen har bara ett element. Då måste slå ihop noder. 364 Strängsökning Specialfall av sökning. Man söker inte ett enstaka element utan en sekvens av element. Elementet ofta tecken, men kan även vara andra typer av data. Formellt: Vi har ett mönster P med längd m och vi söker i en sekvens S av längd n där m<<n. Ett antal algoritmer Naiv Strängsökning Knuth Morris Pratt Booyer Moore Rabin-Karp Första försök till algoritm: Exempel Börja jämföra mönstret med sekvensen med start i position ett. Jämför mönstret från vänster till höger tills man misslyckas. Flytta då fram en position i sekvensen och försök igen. Värsta fallet: Varje element i S avläses m gånger, dvs O(n*m) I praktiken bättre

4 Knuth Morris Pratt Utnyttjar en felfunktion f som berättar hur mycket av mycket av den senaste jämförelsen man kan återanvända om man felar är definierat som det längsta prefixet i P[,...,j] som också är suffix av P[,...,j] där P är vårt mönster. visar hur mycket av början av strängen matchar upp till omedelbart före felet Felfunktion exempel Om jämförelsen felar på position 4, så vet vi att a,b i position 2,3 är identiska med position, j P[j] A B A B A C f(j) KMP-algoritmen KMPfailureFunction(P) Input: String T (text) with n characters and P (pattern) with m characters. Output: Starting index of the first substring of T matching P, or an indication that P is not a substring of T. f <- KMPfailureFunction(P) i <- i <- j <- j <- while i < m- do while i < n do if P[j] = P[i] then if P[j] = S[i] then f(i)<- j+ if j = m- then return i-m- // En matchning i <- i+ i <- i+ j <- j+ j <- j+ else if j > then else if j > ingen match then // ingen match, vi har gått j index direkt efter j <- f(j-) //j index efter pref som match. prefix // matchande prefix i P else //ingen matchning j <- f(j-) f(i) <- else i <- i+ i <- i+ return ingen matchning av delsträngen P i S i KMP exempel a b a c a a b a c c a b a c a b a a a a a a a b a c a b a b a c a b j a b a c a b a b a c a b a b a c a b j P[j] a b a c a b f(j) 2 KMP-Algoritmen Låt k = i - j (startpositionen för ev matchning) För varje varv i while-loopen händer ett av följande: S[i] = P[j], öka i och j med, k oförändrad. S[i] < > P[j] och j >, i är oförändrad men k ökar med minst eftersom den ändras från i - j till i - f(j-) S[i] < > P[j] och j =, öka i med och öka k med (ty j oförändrad). Alltså för varje varv i loppen ökar antingen i eller k med minst. Max antal varv blir 2n Detta antar att f redan är beräknad (som är O(m)). Total komplexitet: O(n + m)

5 Boyer-Moores algoritm Två idéer: Gör matchningen baklänges, med start i mönstrets sista element. Utnyttja kunskap om mönstrets uppbyggnad och informationen om värdet på den första felmatchande elementet i S för att flytta fram mönstret så långt som möjligt varje gång. Om det finns upprepningar av element i mönstret så får man bara flytta fram till den högraste förekomsten. Förskjutningstabell talar om hur långt man får flytta. Rabin-Karp Beräkna ett hashvärde för mönstret och för varje delsträng av texten som man ska jämföra med Om hashvärdena är skilda, beräkna hashvärdet för det nästa M tecknen i texten Om hashvärdena är lika, utför en brute-force jämförelse mellan P och delsträngen Med andra ord: Endast en jämförelse per deltext Brute-force endast när hashvärdena matchar Rabin-Karp exempel Rabin-Karp hashfunktionen Hashvärdet för AAAAA = 37 Hashvärdet för AAAAH = AAAAAAAAAAAAAAAA AAAAH <> 37 AAAAAAAAAAAAAAAA AAAAH <> 37 AAAAAAAAAAAAAAHA AAAAH = Vilken? Den får inte kosta för mycket... Betrakta de nästa M tecknen i söksträngen som ett M-siffrigt tal i basen b, där b är antalet bokstäver i alfabetet Textsekvensen t[i..i+m-] avbildas på talet! x(i) = t[i]b M- + t[i+]b M t[i+m-] Rabin-Karp hashfunktionen Billigt att beräkna x(i+) från x(i)! x(i+) = t[i+]b M- + t[i+2]b M t[i+m] x(i+) = x(i)b! skifta ett vänster,! - t[i]b M! ta bort den vänstraste termen! + t[i+m]! lägg till den nya högertermen Behöver inte räkna om hela talet utan gör bara en justering för det nya tecknet Hash-värdet fortsättning Om M är stort blir blir (b M ) enormt därför så hashar man med mod ett stort primtal q h(i) = ((t[i]b M- mod q) + (t[i+]b M-2 mod q)+...+ (t [i+m-] mod q)) mod q h(i+) = (h(i)b mod q!! - (t[i]b M mod q)!! + (t[i+m] mod q) mod q

6 Algoritm hash_m <- Beräkna hashvärdet för M hash_s <- Beräkna hashvärdet för den första delsträngen do if (hash_m = hash_s) then Bruteforce jämförelse av M och S hash_s + tecken beräknas while end of text or match Komplexitet Om det är tillräckligt stort primtal q för hashfunktionen så kommer hashvärdet från två mönster vara distinkta I detta fall så tar sökningen O(N) där N är antalet tecken i strängen Men det finns alltid fall som ger i närheten av värsta fallet O(N*M) om primtalet är för litet Sortering Varför ska man sortera Sortering vs sorterad datatyp Stabilitet Grundprinciper för sortering Genomgång av några sorteringsalgoritmer Hur fort går det att sortera en lista med n tal? Sortering varför? Snabba upp andra algoritmer Sökning Hantera stora datamängder Sortering vs Sorterad datatyp Sortering förändrar ordningen mellan objekten i en struktur efter en sorteringsordning (fallande, ökande) Sorterad datatyp De strukturförändrande operationerna i gränsytan (insert, delete) upprätthåller en sorteringsordning mellan de lagrade objekten Saker att beakta Absolut komplexitet Totala komplexiteten i alla implementationssteg Tabell->lista->dubbellänkad lista Passar en viss typ av sortering för en viss typ av implementation Ska man sortera och sedan söka eller osorterad plus linjär sökning

7 Stabilitet Den inbördes relationen mellan två objekt med samma nyckel bibehålls vid sortering [(,),(2,3),(5,7),(8,),(,7) ] => [(8,),(2,3), (5,7),(,7),(,)] Alla sorteringsalgoritmer går inte att göra stabila!! Mer om detta senare Olika grundprinciper Insticks O(n 2 ) välj ut ett godtyckligt och sätt in det på rätt plats Urvals O(n 2 ) välj ut det objekt som är på tur och sätt in det sist/först Utbytes O(n*log(n)) byta plats på objekt som ligger fel inbördes Samsortering O(n*log(n)) bygger på sammanslagning av redan sorterade strukturer Nyckelsortering O(m+n) kräver mer information/kunskap om objektmängden Mer principer Naiva sorteringar - O(n 2 ) Insticks, urvals, och vissa utbytes Smarta sorteringar - O(nlog(n)) Utbytes och samsorteringar Ännu smartare sorteringar - O(n+m) Nyckelsorteringar Bubbelsortering for i= to n- do for j= to n- do if (el[j] > el[j+] do swap(el[j],el[j+]) Stabil sortering? Tidskomplexiteten? O(n 2 )för en fältbaserad lista O(?)för en länkad lista? Divide and Conquer Rekursiv algoritm princip Grundidén är att dela upp problemet i mindre och mindre problem Lös dom för basfallet Slå ihop till en totallösning Mergesort och Quicksort är av denna typ Men de jobbar lite annorlunda O(n*log(n)) Algoritm Sortera sekvensen S Mergesort Divide: Om S har 2 eller flera element dela S i två lika stora delsekvenser S och S2 Recurse: Sortera sekvenserna S och S2 rekursivt Conquer: Sätt tillbaka elementen i S genom att slå samman S och S2 till en sorterad sekvens

8 Analys av mergesort Mergesortträd Ta ett binärt träd T Varje nod i T representerar ett rekursivt anrop av mergesort Associera insekvensen för varje anrop med varje nod v i T Externa noder i T representerar varje enskilt element i ursprungssekvensen S Exempel Divide: Om S har 2 eller flera element dela S i två lika stora delsekvenser S och S2 Recurse: Sortera sekvenserna S och S2 rekursivt Conquer: Sätt tillbaka elementen i S genom att slå samman S och S2 till en sorterad sekvens Ihopslagning av två sekvenser Agorithm merge(s,s2,s) while S is not empty and S2 is not empty do if S.first().element()! S2.first().element() then S.insertLast(S.remove(S.first())) else S.insertLast(S2.remove(S2.first())) while S is not empty do S.insertLast(S.remove(S.first())) while S2 is not empty do S.insertLast(S2.remove(S2.first())) Exempel på sammanslagning S S Agorithm merge(s,s2,s) while S is not empty and S2 is not empty do if S.first().element()! S2.first().element() then S.insertLast(S.remove(S.first())) else S.insertLast(S2.remove(S2.first while S is not empty do S.insertLast(S.remove(S.first())) while S2 is not empty do S.insertLast(S2.remove(S2.first())) S Analys av exekveringstiden Höjden på sorteringsträdet kopplat till sorteringen av en sekvens med n element blir log 2 (n) Antag att insättning och borttagning är av O() Tiden i varje nod i trädet exkluderat tiden för det rekursiva jobbet nedanför är O(n/2 i ) där i är djupet på noden ligger på, ty storleken på sekvensen är n/2 i Det är exakt 2 i noder på djupet i => totala tiden på djupet i i trädet är O(2 i n/2 i ) vilket är O(n) och höjden på trädet är log (n) Så den totala tidskomplexiteten är O(nlog(n)) Algoritm Quicksort Välj ut ett pivotelement Dela upp listan i tre delar Less, Equal, Greater Sortera Less och Greater rekursivt Slå ihop Less+Equal+Greater

9 Quicksort - val av pivotelement O(nlog(n) i bästa fallet Valet av pivotelement kritiskt Vill ha ett pivotelement som ligger i mitten Vid sned fördelning får man insticks/urvals sortering med O(n 2 ) Alternativ (eftersträvar en enkel tilldelning) Välj första/sista, slumpmässigt Medel/median mellan några stycken Största av de två första som skiljer sig åt Algoritm Exempel Välj ut ett pivotelement (det första i listan) Dela upp listan i tre delar Less, Equal, Greater Sortera Less och Greater rekursivt Slå ihop Less+Equal+Greater Analys av Quicksort Men medelfallet ligger nära bästa fallet och värsta fallet inträffar förhoppningsvis inte så ofta. Slumpa ett pivotelement borde ge bra tidskomplexitet Inplace variant av quicksort Algoritm Traversera parallellt från båda hållen i S, gå bakåt från början av S tills man hittar ett element som är >= PE, traversera från slutet mot början till man hittar ett element som är < PE Skifta plats på dessa två element Upprepa till traverseringarna mötes Skifta in PE på rätt plats Rekursivt anropa på Less och Greater 4 42 Exempel Hur snabbt kan man sortera? Jämförelsebaserad sortering "(nlog(n)) undre gräns Nyckelsortering snabbare L R R 43 44

10 !(nlog(n)) bevis Exekveringstiden för en jämförelsebaserad sortering måste vara lika med eller större än djupet på det besluts träd som är associerad med algoritmen Varje nod i detta träd är kopplat till en jämförelse som bestämmer ordning mellan två element i S Därav, varje extern nod i T representerar en unik permutation av elementen i S, och det måste finnas n! noder i T, och höjden är log(n!) Eftersom n! Har åtminstone n/2 termer som är större än eller lika med n/2 => log(n!) = log(n/2)n/2= (n/2)log(n/2) => "(nlog(n)) Det att sortera snabbare än O(nlog(n)) För att göra det måste vi veta mer om objekten vi vill sortera Gå att avbilda på heltalen Största värdet & minsta värdet [V min V max ] O(N+M) där N är antalet element och M är V max -V min N (3,k) (,a) (2,h) (9,j) (3,i) (2,o) (8,s) (,e) (7,q) (4,p) (2,y) (9,w) (,m) M Facksortering (,a) (2,h) (,e) (2,o) (,m) (2,y) (3,k) (3,i) (4,p) (7,q) (8,s) (9,j) (9,w) (,a) (,e) (,m) (2,h) (2,o) (2,y) (3,k) (3,i) (4,p) (7,q) (8,s) (9,j) (9,w) Radix Sort Radix # bas Tittar på strukturen hos nycklarna Antag att talen är representerade i basen M, tex. M=2 binära talsystemet 9 = M= decimala talsystemet Sorterar genom att jämföra siffror/bitar i samma position 48 Straight Radix Sort O(bN) for i! to b- do sortera fältet på ett stabilt sätt, med avseende på i:e biten Jämföra från höger till vänster Antag att vi kan sortera fältet stabilt på O (N) => O(bN) Hur gör vi det? Facksortering. Straight Radix Sort 49 4

11 Funkar den? Straight Radix Sort På grund av stabilitet, så förändras inte den relativa ordningen mellan två nycklar med samma värde Straight Radix Sort, med basen Radix Exchange sort Titta på bitarna från vänster till höger. Sortera fältet på den vänstraste biten 2. Dela fältet i två delar toppen & botten 3. Rekursion! Sortera toppen rekursivt, ignorera vänstraste biten! Sortera botten rekursivt, ignorera vänstraste biten O(bN) där b är antalet bitar och N antalet tal Radix Exchange Sort Toppen Botten Radix Exchange Sort Bygger på samma idé som inplace quicksort, för att dela upp i två delar (toppen och botten) repeat scan top-down to find a key starting with ; scan bottom-up to find a key starting with ; exchange keys; until scan indices cross Radix Exchange Sort 45

12 Några av algoritmerna sammanfattade Algoritm Tidskomplexitet Stabil Minne HeapSort O(n log n) nej O() BubbleSort O(n 2 ) ja O() MergeSort O(n log n) ja O(n) InplaceQuicksort max O(n 2 ) medel O(n log n) nej O(log n) InsertionSort O(n 2 ) beror på datatyp O() RadixExchangeSort O(bN) nej O(b)