søgning i
DESCRIPTION
Søgning I. 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. - PowerPoint PPT PresentationTRANSCRIPT
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
- rød-sort-træer
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
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
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
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
( 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
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
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
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
Indsættelse og søgning isorteret 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
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 vedsorteret 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
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
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 afbinær søgning
Kald: info = search(v, 1, N);
15
Implementation afbinæ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
Alternativ implementation afbinæ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
Kompleksiteten af binær søgning
Binær søgning bruger aldrig mere end log2N + 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
E L R
N
G X
18
Antal sammenligninger: Binær søgning:
CB(N) = 1 + CB(N/2) for N ≥ 2, CB(1) = 1
som har løsningen CB(N) = log2(N) + 1, for N ≥ 1.
Ternær søgning: CT(N) = 1/3*1 + 2/3*2 + CT(N/3) for N ≥ 2, CT(1) = 1
som har løsningen CT(N) = 5/3*log3(N) + 1 for N ≥ 1.
Idet 5/3*log3(N) + 1 = 5/3*log2(N)/log2(3) + 1 og 5/3 > log2(3), får vi, at CT(N) > CB(N) for N ≥ 1.
Svaret er altså: nej.
Er ternær søgning bedre end binær søgning?
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
l x r
20
Kompleksiteten af interpolationssøgning
Interpolationssøgning bruger cirka log2log2N + 1 sammenligninger for både succesfuld og mislykket søgning på tilfældige filer.
Færre end 5 forsøg i praksis (225 ≈ 4*1010).
Svagheder: (1) filerne er ikke “tilfældige”, (2) beregningerne af x kan koste mere end de sparede sammenligninger.
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
L R
N
X
head
22
Class Dictionaryimplementeret 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
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
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 log2N 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
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
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
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
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 log2N
Eksempel: N = 106 2 ln N ≈ 27.6log2N ≈ 19.9
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
XK
R
I
C
A
A M P S
L
N
X
K
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 M P S
L
N
X
p
t
x
c
p.l eller p.r
K
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
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
Node removeMin(Node t) { if (t.l == z) { min = t; return t.r;
} t.l = removeMin(t.l); return t; }
RemoveMin(rekursiv udgave)
34
void sort(Node n, Vector V) { if (n == z)
return; sort(n.l, V); V.addElement(n.info); sort(n.r, V);}
Sortering forbinære søgetræer
Inorder-gennemgang af det binære træ
Vector sort() { Vector V = new Vector(); sort(head.r, V); return V; }
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
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 REn 4-knude:
≤ E (> E, ≤ H) (> H ≤ R) > R
H R
En 3-knude:
≤ H (> H, ≤ R) > R
REn 2-knude:
≤ R > R
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
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 SA C
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
(2) Faderen er en 3-knude:
D G
H K M
D G K
H M
Eksempel:
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
Eksempel på konstruktion af et 2-3-4-træ
A B C S
D I R
G H N
D
A B C SNE G H
I
R
Indsættelse af E (roden splittes)
43
A B C SNE G H
D
I
R
Indsættelse af X (simpel)
A B C NE 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
Kompleksitet
Søgning i 2-3-4 træer med N knuder besøger aldrig mere end log2N + 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 log2N + 1 splitninger, og synes at kræve færre end 1 splitning i gennemsnit.
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 afindsættelse i 2-3-4-træer
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
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
A D E G H J L M P S X
K
F
C
A
D
E G
I
J
R
N S
M
LH
P X
48
Søgning og indsættelsei 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 2log2N + 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.002log2N sammenligninger.
49
Splitningstilfælde
(1)
Skift farve på 3 kanter
50
Skift farve på 3 kanter
(2)
51
Vanskelige tilfælde
(3)
?
52
(4)
?
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
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
Rotationer kan retablere rød-sort-egenskaben
HøjrerotationB
A
A
B
A B
A
Venstrerotation
B
56
Dobbeltrotation
C
B
A
VenstrerotationB
CA
Højrerotation
B
C
A
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
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
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
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 analogtmed 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
void insert(int v, String info) {
head = insertRB(head, v, info, false);
head.red = false;
}
Metoden insert
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
• 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
Ugeseddel 621. 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.