1 Søgning I. 2 Plan Sekventiel søgning Binær søgning Binære søgetræer ------------------------------------------- Balancerede binære søgetræer - 2-3-4-træer.

Præsentationer af emnet: "1 Søgning I. 2 Plan Sekventiel søgning Binær søgning Binære søgetræer ------------------------------------------- Balancerede binære søgetræer - 2-3-4-træer."— Præsentationens transcript:

1 1 Søgning I

2 2 Plan Sekventiel søgning Binær søgning Binære søgetræer ------------------------------------------- Balancerede binære søgetræer - 2-3-4-træer - rød-sort-træer

3 3 Søgning er det problem at afgøre, om en mængde af objekter indeholder et objekt, der opfylder visse specificerede krav, og i givet fald finde det. Søgning Søgning er genfinding af lagret information. Informationen har form af poster, der hver har en nøgle. Målet med en søgning er at finde den eller de poster, der har en nøgle, der matcher en given søgenøgle. Søgning er den mest tidsforbrugende aktivitet i mange programmer. At erstatte en dårlig metode med en god fører derfor ofte til en væsentlig effektivitetsforøgelse.

4 4 Klassifikation af søgemetoder intern/ekstern søgning statisk/dynamisk søgning søgning baseret på nøglesammen- ligninger/digitale egenskaber ved nøglerne søgning baseret på de aktuelle nøgler/ transformerede nøgler

5 5 Mængden af poster med tilhørende operationer beskrives ved en abstrakt datatype, Dictionary. Ordbog (symboltabel) en abstrakt datatype til søgning Metoden insert indsætter en ny post med nøgle v og tilknyttet information, info, i ordbogen. Metoden search leder efter en post, der har v som nøgle. Hvis søgningen lykkes, returneres postens tilknyttede information. Ellers returneres en værdi, der indikerer “ingen information” ( infoNil ). class Dictionary { void insert(keyType v, infoType info); infoType search(keyType v); }

6 6 Andre operationer Initialisering (ved hjælp af en eller flere konstruktører) Genfinding af alle poster med en given nøgle: Enumeration searchAll(keyType v) Sletning af poster med en given nøgle: void remove(keyType v) Sortering af en ordbogs poster: Vector sort() Sammenlægning af to ordbøger: Dictionary join(Dictionary other)

7 7 ( keyType = int, infoType = String, infoNil = null ) class Node { int key; String info; } Repræsentation ved usorteret array af poster class Dictionary { private Node a[]; private int N; Dictionary(int max) { a = new Node[max+1]; N = 0; for (int i = 0; i <= max; i++) a[i] = new Node(); } void insert(int v, String info) { a[++N].key = v; a[N].info = info; } String search(int v) {...} }

8 8 String search(int v) { a[0].key = v; a[0].info = null;int i = N+1;while (v != a[-- i].key) ; return a[i].info; } Sekventiel (lineær) søgning Sekventiel søgning, implementeret med usorteret array, bruger altid N+1 sammenligninger for en mislykket søgning og gennemsnitligt (N+1)/2 sammenligninger for en succesfuld søgning. Kompleksitet af søgning er O(N). Kompleksitet af indsættelse er O(1).

9 9 class Node {int key; String info; Node next; Node(int k, String i, Node n) { key = k; info = i; next = n; } } Repræsentation ved usorteret liste af poster class Dictionary { private Node a[], head, z; private int N; Dictionary(int max) { z = new Node(Integer.MAX_VALUE, null, null); head = new Node(0, null, z); } void insert(int v, String info) {... } String search(int v) {... } }

10 10 void insert(int v, String info) { head.next = new Node(v, info, head.next);} Indsættelse og søgning i usorteret liste Kompleksiteten er den samme som for et usorteret array. String search(int v) { Node t = head; while ((t = t.next) != z) if (t.key == v) return t.info; return null; }

11 11 Indsættelse og søgning i sorteret liste void insert(int v, String info) {Node t = head; while (v > t.next.key) t = t.next;t.next = new Node(v, info, t.next); } Sekventiel søgning, implementeret med sorteret liste, bruger gennemsnitligt cirka N/2 sammenlig- ninger for både succesfuld og mislykket søgning. Kompleksiteten af såvel indsættelse som søgning er O(N). String search(int v) { Node t = head; while (v > t.next.key) t = t.next; return v == t.key ? t.info : null; }

12 12 void insert(int v, String info) {int i = ++N; while (a[i- 1].key > v) { a[i] = a[i-1]; i--; } a[i] = new Node(v, info); } Repræsentation ved sorteret array Kompleksiteten af insert er O(N). Metoden search kan implementeres som for usorteret array (med kompleksitet O(N)). Mere effektivt er det dog at benytte binær søgning.

13 13 Binær søgning Metode: Opdel arrayet i to (næsten) lige store dele. Afgør i hvilken af de to dele, nøglen skal findes. Fortsæt søgningen i denne del på samme måde. Eksempel: Søgning efter M. A A A C E E E G H I L M N P R S X I L M N P R S X I L M M

14 14 Rekursiv udgave: String search(int v, int l, int r) { if (l <= r) { int x = (l+r)/2; if (v == a[x].key) return a[x].info; if (v < a[x].key) return search(v, l, x-1); return search(v, x+1, r);} return null; } Implementation af binær søgning Kald: info = search(v, 1, N);

15 15 Implementation af binær søgning Iterativ udgave: String search(int v) { int l = 1, r = N; while (l <= r) { int x = (l+r)/2; if (v == a[x].key) return a[x].info; if (v < a[x].key) r = x-1; else l = x+1;} return null; }

16 16 Alternativ implementation af binær søgning String search(int v) { int l = 1, r = N; while (l < r) { int x = (l+r+1)/2; if (v < a[x].key) r = x-1; else l = x;} return v == a[l].key ? a[l].info : null; } Binær søgning blev første gang beskrevet i 1946. Den første fejlfri udgave blev publiceret i 1960. I 1986 fandt Bentley, at 90% af alle ”computer professionals” ikke kunne skrive en fejlfri udgave på to timer.

17 17 Kompleksiteten af binær søgning Binær søgning bruger aldrig mere end log 2 N + 1 sammenligninger - for såvel succesfuld som mislykket søgning. Binær søgning kan beskrives ved et sammenlignings- træ: H C A A A E E I M P S ELR N G X

18 18 Antal sammenligninger: Binær søgning: C B (N) = 1 + C B (N/2) for N ≥ 2, C B (1) = 1 som har løsningen C B (N) = log 2 (N) + 1, for N ≥ 1. Ternær søgning: C T (N) = 1/3*1 + 2/3*2 + C T (N/3) for N ≥ 2, C T (1) = 1 som har løsningen C T (N) = 5/3*log 3 (N) + 1 for N ≥ 1. Idet 5/3*log 3 (N) + 1 = 5/3*log 2 (N)/log 2 (3) + 1 og 5/3 > log 2 (3), får vi, at C T (N) > C B (N) for N ≥ 1. Svaret er altså: nej. Er ternær søgning bedre end binær søgning?

19 19 Interpolationssøgning Indeksintervallet opdeles efter et gæt på nøglens placering. Ved lineær interpolation sammenholdes søgenøglen med nøglerne i de to intervalendepunkter. I binær søgning erstattes x = (l + r)/2 med x = l + (v- a[l])*(r-l)/(a[r]-a[l]). a[r] a[l] v lxr

20 20 Kompleksiteten af interpolationssøgning Interpolationssøgning bruger cirka log 2 log 2 N + 1 sammenligninger for både succesfuld og mislykket søgning på tilfældige filer. Færre end 5 forsøg i praksis (2 2 5 ≈ 4*10 10 ). Svagheder: (1) filerne er ikke “tilfældige”, (2) beregningerne af x kan koste mere end de sparede sammenligninger.

21 21 Binære søgetræer Ved et binært søgetræ forstås et binært træ bestående af poster med nøgler, hvor der for enhver knude gælder, at alle poster i venstre undertræ er mindre end eller lig med knudens nøgle, mens alle knuder i højre undertræ er større end knudens nøgle. H C A A I M P S LR N X head

22 22 Class Dictionary implementeret ved binære søgetræer class Node { int key; String info; Node l, r; Node(int k, String i, Node ll, Node rr) { key = k; info = i; l = ll; r = rr; }

23 23 class Dictionary { private Node head, z; private int N; Dictionary() { z = new Node(0,null, null, null); head = new Node(Integer.MIN_VALUE, null, null, z); } void insert(int v, String info) {... } String search(int v) {... } void remove(int v) {... } }

24 24 String search(int v) {Node x = head.r;z.key = v; while (v != x.key) x = v < x.key ? x.l : x.r;return x.info; } Søgning i binære søgetræer X M D A Antallet af sammenligninger afhænger af søgetræets udseende. I bedste fald, nemlig når træet er fuldt, udføres cirka log 2 N sammenligninger. I værste fald, nemlig når træet er en lineær liste, udføres N+1 sammenligninger ved mislykket søgning.

25 25 Der foretages en mislykket søgning, og den nye knude indsættes på den eksterne knudes plads. For at knuden kan indsættes i træet, bestemmes dens farknude, p. void insert(int v, String info) { Node p = head, x = head.r; while (x != z) { p = x; x = v < x.key ? x.l : x.r;} x = new Node(v, info, z, z); if (v < p.key) p.l = x; else p.r = x; } Indsættelse i binære søgetræer

26 26 void insert(int v, String info) { insertR(head, v, info); } Node insertR(Node n, int v, String info) { if (n == z) return new Node(v, info, z, z); if (v < n.key) n.l = insertR(n.l, v, info); else n.r = insertR(n.r, v, info); return n; } Rekursiv udgave af insert

27 27 String searchR(Node n, int v) { if (n == z) return null; if (v == n.key) return n.info; if (v < n.key) return searchR(n.l, v); return searchR(n.r, v); } Rekursiv udgave af search public String search(int v) { return searchR(head.r, v); }

28 28 Kompleksiteten af søgning og indsættelse En søgning eller en indsættelse i et binært søgetræ kræver i gennemsnit cirka 2 lnN sammenligninger i et træ, der er opbygget ud fra N tilfældige nøgler. 2 lnN ≈ 1.39 log 2 N Eksempel: N = 10 6 2 ln N ≈ 27.6 log 2 N ≈ 19.9

29 29 Sletning i binære søgetræer Sletning af roden i et binært søgetræ (H): Erstat roden med den næste højere post (I ). R H C A A I M P S L N X K R I C A A M P S L N X K

30 30 c.l = x.r; x.l = t.l; x.r = t.r; if (v < p.key) p.l = x; else p.r = x; Sletning af H R H C A A I MP S L N X p t x c p.l eller p.r K

31 31 void remove(int v) { Node c, p, x, t; z.key = v; p = head; t = head.r; while (v != t.key) { p = t; t = v < t.key ? t.l : t.r; } if (t == z) return; if (v < p.key) p.l = x; else p.r = x; } if (t.r == z) x = t.l; else if (t.r.l == z) { x = t.r; x.l = t.l; } else { c = t.r; while (c.l.l != z) c = c.l; x = c.l; c.l = x.r; x.l = t.l; x.r = t.r; } Metoden remove

32 32 Rekursiv udgave af remove Node removeR(Node t, int v) { if (t == z) return z; if (v < t.key) { t.l = removeR(t.l, v); return t; } if (v > t.key) { t.r = removeR(t.r, v); return t; } if (t.r == z) return t.l; t.r = removeMin(t.r); min.l = t.l; min.r = t.r; return min; } Node min; void remove(int v) { removeR(head, v); }

33 33 Node removeMin(Node t) { if (t.l == z) { min = t; return t.r; } t.l = removeMin(t.l); return t; } RemoveMin ( rekursiv udgave)

34 34 void sort(Node n, Vector V) { if (n == z) return; sort(n.l, V); V.addElement(n.info); sort(n.r, V); } Sortering for binære søgetræer Inorder-gennemgang af det binære træ Vector sort() { Vector V = new Vector(); sort(head.r, V); return V; }

35 35 Balancerede søgetræer Balancering er en teknik, der garanterer, at de værste tilfælde ved søgning ikke forekommer. Ideen er at omorganisere træet under indsættelse, så det bliver fuldt (eller næsten fuldt). I det følgende præsenteres et rød-sort-træ, en datastruktur, der garanterer O(logN) kompleksi- tet både for indsættelse og søgning. Princippet i algoritmerne forklares dog bedst ved hjælp af datastrukturen et 2-3-4-træ.

36 36 Et 2-3-4-træ er et søgetræ, hvor hver knude kan have 2, 3 eller 4 udgående hægter (sønner). 2-3-4-træer E H R En 4-knude: ≤ E (> E, ≤ H) (> H ≤ R) > R H R En 3-knude: ≤ H (> H, ≤ R) > R R En 2-knude: ≤ R > R

37 37 Eksempel på et 2-3-4-træ E R A C H I N S Søgning i et 2-3-4-træ er simpel. (1) Sammenlign søgenøglen med nøglerne i roden. (2) Find intervallet, der indeholder søgenøglen. (3) Følg den tilsvarende hægte (rekursivt).

38 38 Indsættelse i et 2-3-4-træ Foretag en mislykket søgning (søgning til bunden af træet). Hvis 2-knude på bunden: konverter til 3-knude. Hvis 3-knude på bunden: konverter til 4-knude. Hvis 4-knude på bunden: ? E R H I N S A C

39 39 Løsning: Sørg for at der aldrig opstår en 4- knude i bunden! Transformere træet undervejs nedad. Enhver 4-knude, der mødes, “splittes” ved hjælp af én af følgende 3 transformationer: D E G H D G E H Eksempel: (1) Faderen er en 2-knude:

40 40 (2) Faderen er en 3-knude: D G H K M D G K H M Eksempel:

41 41 D G K Eksempel: Invariant: Den aktuelle knude er ikke en 4-knude. Derfor er indsættelse i bunden let. G D K (3, særtilfælde) Roden er en 4-knude:

42 42 Eksempel på konstruktion af et 2-3-4-træ A B CS D I R G H N D A B C S N E G H I R Indsættelse af E (roden splittes)

43 43 A B C S N E G H D I R Indsættelse af X (simpel) A B CN E G H D I R S X Indsættelse af F (transformation 1) N I R S X D G A B C E F H

44 44 Kompleksitet Søgning i 2-3-4 træer med N knuder besøger aldrig mere end log 2 N + 1 knuder. Afstanden fra roden til ethvert blad er den samme. Kun i tilfælde 3 (roden er en 4-knude) øges træets højde. Afstanden til ethvert blad øges med 1. Indsættelse i et 2-3-4 træ med N knuder kræver færre end log 2 N + 1 splitninger, og synes at kræve færre end 1 splitning i gennemsnit.

45 45 void insert(int v) { Node p = head, x = head.r; while (x != z) { p = x; x = theRightLink(p, v); if (isFourNode(x)) x = split(x);} if (p == head) head.r = new TwoNode(v);else if (isTwoNode(p)) makeThree(p, v); else if (isThreeNode(p)) makeFour(p, v); } Direkte implementation er kompliceret på grund af håndtering af forskellige knudetyper split skal kunne håndtere mange tilfælde Skitse til implementation af indsættelse i 2-3-4-træer

46 46 Ide: Repræsenter 2-3-4-træer som binære træer med “indre” kanter for 3- og 4-knuder. Rød-sort-træer Gamle kanter kaldes sorte. Nye kanter kaldes røde. eller

47 47 Invarianter (rød-sort-egenskaberne): (1) Der er aldrig to konsekutive røde kanter på en vej. (2) Enhver vej fra roden til en ekstern knude indeholder det samme antal sorte kanter. Transformation af 2-3-4-træ til rød-sort-træ C F I K N R AD EG H J L M P S X K F C A D E G I J R N S M L H P X

48 48 Søgning og indsættelse i rød-sort-træer Sletning er også simplere (men behandles ikke her). Indsættelse er simplere end for 2-3-4 træer, fordi antallet af splitningstilfælde reduceres. Søgning er sædvanlig søgning i binære søgetræer. En søgning i et rød-sort-træ med N knuder kræver færre end 2log 2 N + 2 sammenligninger. En søgning i et rød-sort-træ med N knuder, der er bygget ud fra tilfældige nøgler bruger i gennemsnit cirka 1.002log 2 N sammenligninger.

49 49 Splitningstilfælde (1) Skift farve på 3 kanter

50 50 Skift farve på 3 kanter (2)

51 51 Vanskelige tilfælde (3) ?

52 52 (4) ?

53 53 En rotation omordner et træ ved at ændre 2 hægter. Ordenen for et binært søgetræ bevares. Højre-rotation: Rotationer B A A B A B B A Venstre-rotation:

54 54 Node rotateR(Node h) { Node x = h.l; h.l = x.r; x.r = h; return x; } Rotationer i Java Node rotateL(Node h) { Node x = h.r; h.r = x.l; x.l = h; return x; } h x x h

55 55 Rotationer kan retablere rød-sort-egenskaben Højrerotation B A A B AB A Venstrerotation B

56 56 Dobbeltrotation C B A Venstrerotation B C A Højrerotation B C A

57 57 Hver knude forsynes med en boolean, red, som er true, hvis og kun hvis kanten op til faderen er rød. class Node { int key; String info; Node l, r; boolean red; Node(int k, String i, Node ll, Node rr, boolean rd) { key = k; info = i; l = ll; r = rr; red = rd; } class Node

58 58 Rekursiv indsættelse i rød-sort-træer Node insertRB(Node t, int v, String info, boolean right) { if (t == z) return new Node(v,info,z,z,true); if (t.l.red && t.r.red) { t.red = true; t.l.red = t.r.red = false; } if (v < t.key) { t.l = insertRB(t.l,v,info,false); if (t.red && t.l.red && right) t = rotateR(t); if (t.l.red && t.l.l.red) { t = rotateR(t); t.red = false; t.r.red = true; } } else {... } return t; }

59 59 De to specielle tilfælde if (t.red && t.l.red && right) t = rotateR(t); t t if (t.l.red && t.l.l.red) { t = rotateR(t); t.red = false; t.r.red = true; } t t

60 60 else { t.r = insertRB(t.r,v,info,true); if (t.red && t.r.red && !right) t = rotateL(t); if (t.r.red && t.r.r.red) { t = rotateL(t); t.red = false; t.l.red = true; } Tilfældet v > t.key er analogt med tilfældet v < t.key l er erstattet med r, r er erstattet med l, right er erstattet med !right, og rotateR er erstattet med rotateL

61 61 void insert(int v, String info) { head = insertRB(head, v, info, false); head.red = false; } Metoden insert

62 62 Konstruktøren i Dictionary Dictionary() { z = new Node(0, null, null, null, false); z.l = z.r = z; head = z; } Node z, head;

63 63 AVL-træ (Adel´son-Vel’skii og Landis) (højdebalanceret træ) Vægt-balanceret træ Splay-træ B-træ (meget velegnet til ekstern søgning) 2-3-træ AA-træ Randomiseret træ Skipliste - et alternativ til binære træer Rød-sort-træ og skipliste anbefales Andre datastrukturer til realisering af binære søgetræer

64 64 Ugeseddel 6 21. oktober - 27. oktober Læs kapitel 16 i lærebogen (side 231-244) Forbered diagnostisk prøve i al gennemgået stof Løs følgende opgaver 1. Opgave 14.5, 14.7, 14.9 og 14.10. 2. Opgave 15.1 og 15.2.