Drzewa wyszukiwa binarnych (BST)

Krzysztof Grzdziel
12 czerwca 2007 roku
1 Drzewa Binarne
Drzewa wyszukiwa binarnych, w skrcie BST (od ang. binary search trees), to szcze-
glny przypadek drzew binarnych. S to struktury, na ktrych mona wykonywa rne
operacje waciwe dla zbiorw dynamicznych, takie jak SEARCH, MINIMUM, MA-
XIMUM, PREDECESSOR, SUCCESSOR, INSERT, DELETE. Drzewo wyszu-
kiwa moe wic by uyte zarwno jako sownik, jak i jako kolejka priorytetowa.
Podstawowe operacje na drzewach wyszukiwa binarnych wymagaj czasu proporcjo-
nalnego do wysokoci drzewa. W penym drzewie binarnym o n wzach takie operacje
dziaaj w przypadku pesymistyzcznym w czasie (lg n). Jeli jednak drzewo skada si z
jednej gaezi o dugoci n, to te same operacje wymagaj w przypadku pesymistycznym
czasu (n).
1.1 Co to jest drzewo wyszukiwa binarnych?
Rysunek 1: Drzewo poszukiwa binarnych o wadze rwnej 9, a wysokoci rwnej 3; wierzchoek
8 jest tu korzeniem, a wierzchoki 1, 4, 7 i 13, to licie.
Drzewo wyszukiwa binarnych, ma struktur drzewa binarnego. Takie drzewa mona
zrealizowa za pomoc struktury danych z dowizaniami, w ktrej kady wze jest obiek-
tem. Oprcz pola key (ew. danych dodatkowych), kady wze zawiera pola left, right,
oraz p (parent), ktre wskazuj, odpowiednio, na jego lewego syna, prawego syna, oraz
rodzica. Jeli wze nie ma nastpnika albo poprzednika, to odpowiednie pole ma warto
1
NIL. Wze w korzeniu drzewa jest jedynym wzem, ktrego pole wskazujce na ojca
ma warto NIL.
Klucze s przechowywane w drzewie BST w taki sposb, ale speniona bya wasno
drzewa BST:
Niech x bdzie wzem drzewa BST. Jeli y jest wzem znajdujcym si w le-
wym poddrzewie wza x, to key[y] key[x]. Jeli y jest wzem znajdujcym
si w prawym poddrzewie wza x, to key[y] key[x].
1.2 Wybrane zoonoci
Wypisanie drzewa (n)
Wyszukanie O(h)
Znajdowanie minimum O(h)
Znajdowanie maksimum O(h)
Znajdowanie poprzednika O(h)
Znajdowanie nastpnika O(h)
Wstawianie O(h)
Usuwanie O(h)
gdzie n - ilo wzw w drzewie, h - wysoko drzewa
2 Funkcje
2.1 echo
void echo(BST *root)
Wypisuje na standardowe wyjcie key danego wza.
Parametry:
root - wskaznik to korzenia
2.2 inorder
void inorder(BST *root)
Przechodzenie drzewa BST metoda inorder. Klucz drzewa zostaje wypisany mi-
dzy wartociami jego lewego poddrzewa, a wartociami z jego prawego poddrzewa.
Parametry:
root - wskaznik to korzenia
2.3 preorder
void preorder(BST *root)
Przechodzenie drzewa BST metoda preorder. Wypisuje klucz korzenia przed wy-
pisaniem wartoci znajducych si w obu poddrzewach.
2
Parametry:
root - wskaznik to korzenia
2.4 postorder
void postorder(BST *root)
Przechodzenie drzewa BST metoda postorder. Wypisuje klucz korzenia po wypi-
saniu wartoci znajducych si w obu poddrzewach.
Parametry:
root - wskaznik to korzenia
2.5 postorderinverse
void postorderinverse(BST *root)
Przechodzenie drzewa BST metoda odwrotn do preorder. Wypisuje klucze ko-
rzenia w kolejnoci odwrotnej do preorder.
Parametry:
root - wskaznik to korzenia
2.6 search
BST *search(BST *root, int val)
Wyszukiwanie wza (rekurencyjnie), ktry zawiera klucz val.
Parametry:
root - wskaznik to korzenia val - szukany klucz
2.7 isearch
BST *isearch(BST *root,int val)
Iteracyjne wyszukiwanie wza, ktry zawiera klucz val.
Uwaga!
Efektywniejsze od serach(BST*,int);
Parametry:
root - wskaznik to korzenia val - szukany klucz
2.8 min
BST *min(BST *root)
Znajdowanie najmniejszej wartoci w drzewie.
Parametry:
root - wskaznik to korzenia
3
2.9 max
BST *max(BST *root)
Znajdowanie najwikszej wartoci w drzewie.
Parametry:
root - wskaznik to korzenia
2.10 trace
void trace(BST *root, int v1, int v2)
Znajduje droge pomiedzy dwoma kluczami.
Parametry:
root - wskaznik to korzenia v1 - klucz pocztkowy v2 - klucz kocowy
2.11 draw
void draw(BST* root)
Rysuje drzewo.
Parametry:
root - wskaznik to korzenia
2.12 nastepnik
BST *nastepnik(BST *root)
Znajduje nastpnik danego wza.
Parametry:
root - wskaznik to wza
2.13 poprzednik
BST *poprzednik(BST *root)
Znajduje poprzednika danego wza.
Parametry:
root - wskaznik to wza
2.14 del
BST *del(BST *root, int val)
Usuwa wze o danym kluczu val.
Parametry:
root - wskaznik to korzenia val - warto klucza
4
2.15 add
BST *add(BST *root, int val)
Dodaje wze o kluczu val do drzewa wyszukiwa binarnych.
Parametry:
root - wskaznik to korzenia val - warto klucza
2.16 waga
int waga(BST *root)
Zwraca ilo wzw w drzewie.
Parametry:
root - wskaznik to korzenia
3 Implementacja
3.1 Plik nagwkowy
Listing 1: bst.h
1 #i f ndef INC BST H
2 #define INC BST H
3
4 typedef struct drzewo BST;
5 struct drzewo {
6 i nt key ;
7 BST l e f t ;
8 BST r i ght ;
9 BST p ; // parent
10 };
11
12 extern void echo (BST r oot ) ;
13 extern void i nor de r (BST r oot ) ;
14 extern void pr eor der (BST r oot ) ;
15 extern void pos t or der (BST r oot ) ;
16 extern void pos t or de r i nve r s e (BST r oot ) ;
17 extern BST s ear ch (BST root , i nt val ) ;
18 extern BST i s e ar c h (BST root , i nt val ) ;
19 extern BST min(BST r oot ) ;
20 extern BST max(BST r oot ) ;
21 extern void t r ac e (BST root , i nt v1 , i nt v2 ) ;
22 extern void draw(BST r oot ) ;
23 extern BST nas t epni k (BST r oot ) ;
24 extern BST poprzedni k (BST r oot ) ;
25 extern BST del (BST root , i nt val ) ;
26 extern BST add(BST root , i nt val ) ;
27 extern i nt waga(BST r oot ) ;
28
29 #endif
3.2 Funkcje drzewa BST
Listing 2: Implementacja operacji na drzewie BST (bst.c)
1 #include<s t di o . h>
2 #include<mal l oc . h>
3 #include bst . h
4
5 // wys wi et l a key z podanego wskazni ka
6 void echo (BST r oot ){
5
7 i f ( r oot != NULL) pr i nt f ( %d\n , root >key ) ;
8 el se pr i nt f ( brak\n ) ;
9 return ;
10 }
11
12 // wypi suj e drzewo w porzadku i noder ( posortowane rosnaco )
13 void i nor de r (BST r oot ){
14 i f ( r oot != NULL){
15 i nor de r ( root >l e f t ) ;
16 pr i nt f ( %d , root >key ) ;
17 i nor de r ( root >r i ght ) ;
18 }
19 return ;
20 }
21
22 // wypi sywani e drzewa w porzadku preorder
23 void pr eor der (BST r oot ){
24 i f ( r oot != NULL){
25 pr i nt f ( %d , root >key ) ;
26 pr eor der ( root >l e f t ) ;
27 pr eor der ( root >r i ght ) ;
28 }
29 return ;
30 }
31
32 // wypi sywani e drzewa w porzadku pos t order
33 void pos t or der (BST r oot ){
34 i f ( r oot != NULL){
35 pos t or der ( root >l e f t ) ;
36 pos t or der ( root >r i ght ) ;
37 pr i nt f ( %d , root >key ) ;
38 }
39 return ;
40 }
41
42 // wypi sywani e drzewa w porzadku odwrotnym do pos t order
43 void pos t or de r i nve r s e (BST r oot ){
44 i f ( r oot != NULL){
45 pr i nt f ( %d , root >key ) ;
46 pos t or de r i nve r s e ( root >r i ght ) ;
47 pos t or de r i nve r s e ( root >l e f t ) ;
48 }
49 return ;
50 }
51
52 // szukani e rekurencyj ne
53 BST s ear ch (BST root , i nt val ){
54 i f ( ( r oot == NULL) | | ( val == root >key ) ) return r oot ;
55 i f ( val < root >key ){
56 return s ear ch ( root >l e f t , val ) ;
57 }
58 el se {
59 return s ear ch ( root >r i ght , val ) ;
60 }
61 return r oot ;
62 }
63
64 // prz es z uki wani e i t e r ac y j ne ( e f e k t y wni e j s z e )
65 BST i s e ar c h (BST root , i nt val ){
66 while ( ( r oot != NULL) && ( val != root >key ) ) {
67 i f ( val < root >key ) r oot = root >l e f t ;
68 el se r oot = root >r i ght ;
69 }
70 return r oot ;
71 }
72
73 // znaj dowani e minimum
74 BST min(BST r oot ){
75 while ( root >l e f t != NULL){
76 r oot = root >l e f t ;
77 }
78 return r oot ;
79 }
6
80
81 // znaj dowani e maksimum
82 BST max(BST r oot ){
83 while ( root >r i ght != NULL){
84 r oot = root >r i ght ;
85 }
86 return r oot ;
87 }
88
89 //wskazywanie dr ogi pomiedzy dwoma el ementami
90 void t r ac e (BST root , i nt v1 , i nt v2 ){
91 BST x = i s e ar c h ( root , v1 ) ;
92 BST y = i s e ar c h ( root , v2 ) ;
93
94 i f ( v1 > v2 ){
95 i nt tmp=v2 ;
96 v2=v1 ;
97 v1=tmp ;
98 }
99 // p r i nt f (\ t key :%d\n , root >key ) ;
100 i f ( r oot==NULL | | x==NULL | | y==NULL){
101 pr i nt f ( brak dr ogi ) ;
102 }
103 el se {
104 i f ( v1<root >key && v2 < root >key ){
105 t r ac e ( root >l e f t , v1 , v2 ) ;
106 }
107 i f ( v1>root >key && v2 > root >key ){
108 t r ac e ( root >r i ght , v1 , v2 ) ;
109 }
110 i f ( v1<=root >key && v2 >= root >key ){
111 while ( x != r oot ){
112 pr i nt f ( %d , x>key ) ;
113 x=x>p ;
114 }
115 pr i nt f ( %d , x>key ) ;
116 while ( r oot != y){
117 i f ( y>key < root >key ){
118 r oot = root >l e f t ;
119 pr i nt f ( %d , root >key ) ;
120 }
121 i f ( y>key > root >key ){
122 r oot = root >r i ght ;
123 pr i nt f ( %d , root >key ) ;
124 }
125 }
126 }
127 }
128 }
129
130 // r ys uj e drzewo
131 void draw(BST r oot ){
132 i f ( r oot != NULL){
133 pr i nt f ( %3d , root >key ) ;
134 i f ( root >l e f t == NULL && root >r i ght == NULL) ;
135 el se {
136 pr i nt f ( ( ) ;
137 i f ( root >l e f t != NULL) pr i nt f ( %3d , , root >l e f t >key ) ; el se pr i nt f ( .
, ) ;
138 i f ( root >r i ght != NULL) pr i nt f ( %3d , root >r i ght >key ) ; el se pr i nt f (
. ) ;
139 pr i nt f ( ) ) ;
140 }
141 pr i nt f ( \n ) ;
142 }
143 i f ( root >l e f t !=NULL) draw( root >l e f t ) ;
144 i f ( root >r i ght !=NULL) draw( root >r i ght ) ;
145 }
146
147 // s ucces s or
148 BST nas t epni k (BST r oot ){
149 BST y = r oot ;
150
7
151 // except i on
152 i f ( r oot==NULL) return y ;
153
154 i f ( root >r i ght != NULL){
155 return min( root >r i ght ) ;
156 }
157 y = root >p ;
158 while ( y != NULL && r oot == y>r i ght ){
159 r oot = y ;
160 y = y>p ;
161 }
162 return y ;
163 }
164
165 // predeces s or
166 BST poprzedni k (BST r oot ){
167 BST y = r oot ;
168
169 // except i on
170 i f ( r oot==NULL) return y ;
171
172 i f ( root >l e f t != NULL){
173 return max( root >l e f t ) ;
174 }
175 y = root >p ;
176 while ( y!=NULL && r oot == y>l e f t ){
177 r oot = y ;
178 y = y>p ;
179 }
180 return y ;
181 }
182
183 //usuwanie
184 BST del (BST root , i nt val ){
185 // ws kaz ni ki pomocnicze
186 BST x = r oot ;
187 BST y = (BST) mal l oc ( si zeof (BST) ) ;
188 // t o co usuwamy
189 BST del = s ear ch ( root , val ) ;
190
191 i f ( del == NULL) return y ;
192
193 i f ( del >l e f t==NULL | | del >r i ght==NULL) y=del ;
194 el se y=nas t epni k ( del ) ;
195
196 i f ( y>l e f t !=NULL) x=y>l e f t ;
197 el se x=y>r i ght ;
198
199 i f ( x!=NULL) x>p = y>p ;
200
201 i f ( y>p == NULL) r oot = x ;
202 el se i f ( y == y>p>l e f t ) y>p>l e f t = x ;
203 el se y>p>r i ght = x ;
204
205 i f ( y!=del ){
206 del >key = y>key ;
207 }
208 return y ;
209 }
210
211 // dodawanie
212 BST add(BST root , i nt val ){
213 BST x = r oot ;
214
215 // nowy obi ekt , kt or y wpinany j e s t do drzewa
216 BST nowe = (BST ) mal l oc ( si zeof (BST) ) ;
217 nowe>key = val ;
218 nowe>p = nowe>l e f t = nowe>r i ght = NULL;
219
220 BST y = NULL;
221 while ( x != NULL){
222 y = x ;
223 i f ( val < x>key ) x = x>l e f t ;
8
224 el se x = x>r i ght ;
225 }
226 nowe>p = y ;
227 i f ( y == NULL) r oot = nowe ;
228 el se {
229 i f ( nowe>key < y>key ) y>l e f t = nowe ;
230 el se y>r i ght = nowe ;
231 }
232 return r oot ;
233 }
234
235 // o b l i c z a i l o s c wezl ow w drzewi e
236 i nt waga(BST r oot ){
237 i f ( r oot == NULL) return 0;
238 el se return waga( root >l e f t ) + waga( root >r i ght ) + 1;
239 }
3.3 Przykad uycia
Listing 3: Przykad uycia
1 #include<s t di o . h>
2 #include<mal l oc . h>
3 #include bst . h
4
5 i nt main ( ) {
6 BST t r e e = NULL;
7
8 t r e e = add( t r ee , 1 5 ) ;
9 t r e e = add( t r ee , 6 ) ;
10 t r e e = add( t r ee , 3 ) ;
11 t r e e = add( t r ee , 7 ) ;
12 t r e e = add( t r ee , 2 ) ;
13 t r e e = add( t r ee , 4 ) ;
14 t r e e = add( t r ee , 1 3 ) ;
15 t r e e = add( t r ee , 9 ) ;
16 t r e e = add( t r ee , 1 8 ) ;
17 t r e e = add( t r ee , 1 7 ) ;
18 t r e e = add( t r ee , 2 0 ) ;
19
20 pr i nt f ( i nor de r ( ) : ) ;
21 i nor de r ( t r e e ) ;
22 pr i nt f ( \ npos t or der ( ) : ) ;
23 pos t or der ( t r e e ) ;
24 pr i nt f ( \ npos t or de r i nve r s e ( ) : ) ;
25 pos t or de r i nve r s e ( t r e e ) ;
26 pr i nt f ( \ npr eor der ( ) : ) ;
27 pr eor der ( t r e e ) ;
28 pr i nt f ( \ nsearch ( 2 ) : ) ;
29 s ear ch ( t r ee , 2 ) ;
30 pr i nt f ( \ nsearch ( 7 ) : ) ;
31 s ear ch ( t r ee , 7 ) ;
32 pr i nt f ( \nmin ( 7 ) : ) ;
33 echo ( min( t r e e ) ) ;
34 pr i nt f ( max( 7 ) : ) ;
35 echo (max( t r e e ) ) ;
36 i nt nst =15;
37 pr i nt f ( Nastepni k %d : , nst ) ;
38 echo ( nas t epni k ( s ear ch ( t r ee , nst ) ) ) ;
39 pr i nt f ( Poprzedni k %d : , nst ) ;
40 echo ( poprzedni k ( s ear ch ( t r ee , nst ) ) ) ;
41 del ( t r ee , nst ) ;
42 pr i nt f ( Waga drzewa : %d\n , waga( t r e e ) ) ;
43 pr i nt f ( Droga ( 17 , 20) : ) ;
44 t r ac e ( t r ee , 1 7 , 2 0 ) ;
45 pr i nt f ( \nDroga ( 20 , 17) : ) ;
46 t r ac e ( t r ee , 2 0 , 1 7 ) ;
47 pr i nt f ( \nDroga ( 20 , 26) : ) ;
48 t r ac e ( t r ee , 2 0 , 2 6 ) ;
49 pr i nt f ( \n ) ;
50 return 0;
51 }
9
Literatura
[1] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Cliord Stein, Wpro-
wadzenie do algorytmw, WNT, Warszawa 2005.
10