Drzewa wyszukiwań binarnych (BST)

Krzysztof Grządziel

12 czerwca 2007 roku

Drzewa Binarne

Drzewa wyszukiwań binarnych, w skrócie BST (od ang. binary search trees), to szcze-

gólny przypadek drzew binarnych. Są to struktury, na których można wykonywać różne
operacje właściwe dla zbiorów dynamicznych, takie jak SEARCH, MINIMUM, MA-
XIMUM, PREDECESSOR, SUCCESSOR, INSERT, DELETE. Drzewo wyszu-
kiwań może więc być użyte zarówno jako słownik, jak i jako kolejka priorytetowa.

Podstawowe operacje na drzewach wyszukiwań binarnych wymagają czasu proporcjo-

nalnego do wysokości drzewa. W pełnym drzewie binarnym o n węzłach takie operacje
działają w przypadku pesymistyzcznym w czasie θ(lg n). Jeśli jednak drzewo składa się z
jednej gałezi o długości 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 równej 9, a wysokości równej 3; wierzchołek

’8’ jest tu korzeniem, a wierzchołki ’1’, ’4’, ’7’ i ’13’, to liście.

Drzewo wyszukiwań binarnych, ma strukturę drzewa binarnego. Takie drzewa można

zrealizować za pomocą struktury danych z dowiązaniami, w której każdy węzeł jest obiek-
tem. Oprócz pola key (ew. danych dodatkowych), każdy węzeł zawiera pola lef t, right,
oraz p (parent), które wskazują, odpowiednio, na jego lewego syna, prawego syna, oraz
rodzica. Jeśli węzeł nie ma następnika albo poprzednika, to odpowiednie pole ma wartość

N IL. Węzeł w korzeniu drzewa jest jedynym węzłem, którego pole wskazujące na ojca
ma wartość N IL.

Klucze są przechowywane w drzewie BST w taki sposób, ale spełniona była własność

drzewa BST:

Niech x będzie węzłem drzewa BST. Jeśli y jest węzłem znajdującym się w le-
wym poddrzewie węzła x, to key[y] ¬ key[x]. Jeśli y jest węzłem znajdującym
się w prawym poddrzewie węzła x, to key[y]  key[x].

1.2

Wybrane złożoności

Wypisanie drzewa

θ(n)

Wyszukanie

O(h)

Znajdowanie minimum

O(h)

Znajdowanie maksimum

O(h)

Znajdowanie poprzednika

O(h)

Znajdowanie następnika

O(h)

Wstawianie

O(h)

Usuwanie

O(h)

gdzie n - ilość węzłów w drzewie, h - wysokość drzewa

Funkcje

2.1

echo

void echo(BST *root)

Wypisuje na standardowe wyjście key danego węzła.

Parametry:
root - wskaznik to korzenia

2.2

inorder

void inorder(BST *root)

Przechodzenie drzewa BST metoda inorder. Klucz drzewa zostaje wypisany mię-

dzy wartościami jego lewego poddrzewa, a wartościami 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 wartości znajduących się w obu poddrzewach.

Parametry:
root - wskaznik to korzenia

2.4

postorder

void postorder(BST *root)

Przechodzenie drzewa BST metoda postorder. Wypisuje klucz korzenia po wypi-

saniu wartości znajduących 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 kolejności odwrotnej do preorder.

Parametry:
root - wskaznik to korzenia

2.6

search

BST *search(BST *root, int val)

Wyszukiwanie węzła (rekurencyjnie), który zawiera klucz val.

Parametry:
root - wskaznik to korzenia val - szukany klucz

2.7

isearch

BST *isearch(BST *root,int val)

Iteracyjne wyszukiwanie węzła, który 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 wartości w drzewie.

Parametry:
root - wskaznik to korzenia

2.9

max

BST *max(BST *root)

Znajdowanie największej wartości 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 początkowy v2 - klucz końcowy

2.11

draw

void draw(BST* root)

Rysuje drzewo.

Parametry:
root - wskaznik to korzenia

2.12

nastepnik

BST *nastepnik(BST *root)

Znajduje następnik danego węzła.

Parametry:
root - wskaznik to węzła

2.13

poprzednik

BST *poprzednik(BST *root)

Znajduje poprzednika danego węzła.

Parametry:
root - wskaznik to węzła

2.14

del

BST *del(BST *root, int val)

Usuwa węzeł o danym kluczu val.

Parametry:
root - wskaznik to korzenia val - wartość klucza

2.15

add

BST *add(BST *root, int val)

Dodaje węzeł o kluczu val do drzewa wyszukiwań binarnych.

Parametry:
root - wskaznik to korzenia val - wartość klucza

2.16

waga

int waga(BST *root)

Zwraca ilość węzłów w drzewie.

Parametry:
root - wskaznik to korzenia

Implementacja

3.1

Plik nagłówkowy

Listing 1: bst.h

#i f n d e f INC BST H

#d e f i n e INC BST H

typedef s t r u c t drzewo BST ;

s t r u c t drzewo {

i n t key ;

BST ∗ l e f t ;

BST ∗ r i g h t ;

BST ∗p ; // p a r e n t

} ;

extern void e c h o (BST ∗ r o o t ) ;

extern void i n o r d e r (BST ∗ r o o t ) ;

extern void p r e o r d e r (BST ∗ r o o t ) ;

extern void p o s t o r d e r (BST ∗ r o o t ) ;

extern void p o s t o r d e r i n v e r s e (BST ∗ r o o t ) ;

extern BST ∗ s e a r c h (BST ∗ r o o t ,

i n t v a l ) ;

extern BST ∗ i s e a r c h (BST ∗ r o o t , i n t v a l ) ;

extern BST ∗ min (BST ∗ r o o t ) ;

extern BST ∗max (BST ∗ r o o t ) ;

extern void t r a c e (BST ∗ r o o t ,

i n t v1 ,

i n t v2 ) ;

extern void draw (BST∗ r o o t ) ;

extern BST ∗ n a s t e p n i k (BST ∗ r o o t ) ;

extern BST ∗ p o p r z e d n i k (BST ∗ r o o t ) ;

extern BST ∗ d e l (BST ∗ r o o t ,

i n t v a l ) ;

extern BST ∗ add (BST ∗ r o o t ,

i n t v a l ) ;

extern i n t waga (BST ∗ r o o t ) ;

#e n d i f

3.2

Funkcje drzewa BST

Listing 2: Implementacja operacji na drzewie BST (bst.c)

#include<s t d i o . h>

#include<m a l l o c . h>

#include ” b s t . h”

// w y s w i e t l a k e y z podanego w s k a z n i k a

void e c h o (BST ∗ r o o t ) {

i f ( r o o t != NULL)

p r i n t f ( ”%d\n” , r o o t −>key ) ;

e l s e

p r i n t f ( ” b r a k \n” ) ;

return ;

}

// w y p i s u j e d r z e w o w p o r z a d k u i n o d e r ( p o s o r t o w a n e r o s n a c o )

void i n o r d e r (BST ∗ r o o t ) {

i f ( r o o t != NULL) {

i n o r d e r ( r o o t −> l e f t ) ;

p r i n t f ( ”%d ” , r o o t −>key ) ;

i n o r d e r ( r o o t −>r i g h t ) ;

}

return ;

}

// w y p i s y w a n i e d r z e w a w p o r z a d k u p r e o r d e r

void p r e o r d e r (BST ∗ r o o t ) {

i f ( r o o t != NULL) {

p r i n t f ( ”%d ” , r o o t −>key ) ;

p r e o r d e r ( r o o t −> l e f t ) ;

p r e o r d e r ( r o o t −>r i g h t ) ;

}

return ;

}

// w y p i s y w a n i e d r z e w a w p o r z a d k u p o s t o r d e r

void p o s t o r d e r (BST ∗ r o o t ) {

i f ( r o o t != NULL) {

p o s t o r d e r ( r o o t −> l e f t ) ;

p o s t o r d e r ( r o o t −>r i g h t ) ;

p r i n t f ( ”%d ” , r o o t −>key ) ;

}

return ;

}

// w y p i s y w a n i e d r z e w a w p o r z a d k u odwrotnym do p o s t o r d e r

void p o s t o r d e r i n v e r s e (BST ∗ r o o t ) {

i f ( r o o t != NULL) {

p r i n t f ( ”%d ” , r o o t −>key ) ;

p o s t o r d e r i n v e r s e ( r o o t −>r i g h t ) ;

p o s t o r d e r i n v e r s e ( r o o t −> l e f t ) ;

}

return ;

}

// s z u k a n i e

r e k u r e n c y j n e

BST ∗ s e a r c h (BST ∗ r o o t ,

i n t v a l ) {

i f ( ( r o o t == NULL)

| |

( v a l == r o o t −>key ) ) return r o o t ;

i f ( v a l < r o o t −>key ) {

return s e a r c h ( r o o t −>l e f t , v a l ) ;

}

e l s e {

return s e a r c h ( r o o t −>r i g h t , v a l ) ;

}

return r o o t ;

}

// p r z e s z u k i w a n i e

i t e r a c y j n e

( e f e k t y w n i e j s z e )

BST ∗ i s e a r c h (BST ∗ r o o t , i n t v a l ) {

while ( ( r o o t != NULL) && ( v a l != r o o t −>key ) ) {

i f ( v a l < r o o t −>key ) r o o t = r o o t −> l e f t ;

e l s e

r o o t = r o o t −>r i g h t ;

}

return r o o t ;

}

// z n a j d o w a n i e minimum

BST ∗ min (BST ∗ r o o t ) {

while ( r o o t −> l e f t

!= NULL) {

r o o t = r o o t −> l e f t ;

}

return r o o t ;

}

// z n a j d o w a n i e maksimum

BST ∗max (BST ∗ r o o t ) {

while ( r o o t −>r i g h t != NULL) {

r o o t = r o o t −>r i g h t ;

}

return r o o t ;

}

// w s k a z y w a n i e d r o g i pomiedzy dwoma e l e m e n t a m i

void t r a c e (BST ∗ r o o t ,

i n t v1 ,

i n t v2 ) {

BST∗ x = i s e a r c h ( r o o t , v1 ) ;

BST∗ y = i s e a r c h ( r o o t , v2 ) ;

i f ( v1 > v2 ) {

i n t tmp=v2 ;

v2=v1 ;

v1=tmp ;

}

// p r i n t f ( ” \ t k e y :%d \n ” , r o o t −>k e y ) ;

100

i f ( r o o t==NULL | |

x==NULL | |

y==NULL) {

101

p r i n t f ( ” b r a k d r o g i ” ) ;

102

}

103

e l s e {

104

i f ( v1<r o o t −>key && v2 < r o o t −>key ) {

105

t r a c e ( r o o t −>l e f t , v1 , v2 ) ;

106

}

107

i f ( v1>r o o t −>key && v2 > r o o t −>key ) {

108

t r a c e ( r o o t −>r i g h t , v1 , v2 ) ;

109

}

110

i f ( v1<=r o o t −>key && v2 >= r o o t −>key ) {

111

while ( x != r o o t ) {

112

p r i n t f ( ”%d ” , x−>key ) ;

113

x=x−>p ;

114

}

115

p r i n t f ( ”%d ” , x−>key ) ;

116

while ( r o o t != y ) {

117

i f ( y−>key < r o o t −>key ) {

118

r o o t = r o o t −> l e f t ;

119

p r i n t f ( ”%d ” , r o o t −>key ) ;

120

}

121

i f ( y−>key > r o o t −>key ) {

122

r o o t = r o o t −>r i g h t ;

123

p r i n t f ( ”%d ” , r o o t −>key ) ;

124

}

125

}

126

}

127

}

128

}

129

130

// r y s u j e d r z e w o

131

void draw (BST∗ r o o t ) {

132

i f ( r o o t != NULL) {

133

p r i n t f ( ”%−3d” , r o o t −>key ) ;

134

i f ( r o o t −> l e f t == NULL && r o o t −>r i g h t == NULL ) ;

135

e l s e {

136

p r i n t f ( ” ( ” ) ;

137

i f ( r o o t −> l e f t

!= NULL)

p r i n t f ( ”%−3d , ” , r o o t −>l e f t −>key ) ;

e l s e

p r i n t f ( ” .

, ” ) ;

138

i f ( r o o t −>r i g h t != NULL)

p r i n t f ( ”%3d” , r o o t −>r i g h t −>key ) ;

e l s e

p r i n t f ( ”

. ” ) ;

139

p r i n t f ( ” ) ” ) ;

140

}

141

p r i n t f ( ” \n” ) ;

142

}

143

i f ( r o o t −> l e f t

!=NULL) draw ( r o o t −> l e f t ) ;

144

i f ( r o o t −>r i g h t !=NULL) draw ( r o o t −>r i g h t ) ;

145

}

146

147

// s u c c e s s o r

148

BST ∗ n a s t e p n i k (BST ∗ r o o t ) {

149

BST∗ y = r o o t ;

150

151

// e x c e p t i o n

152

i f ( r o o t==NULL) return y ;

153

154

i f ( r o o t −>r i g h t != NULL) {

155

return min ( r o o t −>r i g h t ) ;

156

}

157

y = r o o t −>p ;

158

while ( y != NULL && r o o t == y−>r i g h t ) {

159

r o o t = y ;

160

y = y−>p ;

161

}

162

return y ;

163

}

164

165

// p r e d e c e s s o r

166

BST ∗ p o p r z e d n i k (BST ∗ r o o t ) {

167

BST∗ y = r o o t ;

168

169

// e x c e p t i o n

170

i f ( r o o t==NULL) return y ;

171

172

i f ( r o o t −> l e f t

!= NULL) {

173

return max ( r o o t −> l e f t ) ;

174

}

175

y = r o o t −>p ;

176

while ( y !=NULL && r o o t == y−> l e f t ) {

177

r o o t = y ;

178

y = y−>p ;

179

}

180

return y ;

181

}

182

183

// u s u w a n i e

184

BST ∗ d e l (BST ∗ r o o t ,

i n t v a l ) {

185

// w s k a z n i k i p o m o c n i c z e

186

BST∗ x = r o o t ;

187

BST∗ y = (BST∗ ) m a l l o c ( s i z e o f (BST ) ) ;

188

// t o co usuwamy

189

BST∗ d e l = s e a r c h ( r o o t , v a l ) ;

190

191

i f ( d e l == NULL) return y ;

192

193

i f ( d e l −> l e f t==NULL | |

d e l −>r i g h t==NULL) y=d e l ;

194

e l s e y=n a s t e p n i k ( d e l ) ;

195

196

i f ( y−> l e f t !=NULL) x=y−> l e f t ;

197

e l s e x=y−>r i g h t ;

198

199

i f ( x !=NULL) x−>p = y−>p ;

200

201

i f ( y−>p == NULL) r o o t = x ;

202

e l s e

i f ( y == y−>p−> l e f t ) y−>p−> l e f t = x ;

203

e l s e y−>p−>r i g h t = x ;

204

205

i f ( y != d e l ) {

206

d e l −>key = y−>key ;

207

}

208

return y ;

209

}

210

211

// dodawanie

212

BST ∗ add (BST ∗ r o o t ,

i n t v a l ) {

213

BST ∗ x = r o o t ;

214

215

// nowy o b i e k t ,

k t o r y wpinany

j e s t do d r z e w a

216

BST ∗ nowe = (BST ∗ ) m a l l o c ( s i z e o f (BST ) ) ;

217

nowe−>key = v a l ;

218

nowe−>p = nowe−> l e f t = nowe−>r i g h t = NULL ;

219

220

BST ∗ y = NULL ;

221

while ( x != NULL) {

222

y = x ;

223

i f ( v a l < x−>key ) x = x−> l e f t ;

224

e l s e x = x−>r i g h t ;

225

}

226

nowe−>p = y ;

227

i f ( y == NULL) r o o t = nowe ;

228

e l s e {

229

i f ( nowe−>key < y−>key ) y−> l e f t = nowe ;

230

e l s e y−>r i g h t = nowe ;

231

}

232

return r o o t ;

233

}

234

235

// o b l i c z a

i l o s c

w e z l o w w d r z e w i e

236

i n t waga (BST ∗ r o o t ) {

237

i f ( r o o t == NULL) return 0 ;

238

e l s e return waga ( r o o t −> l e f t ) + waga ( r o o t −>r i g h t ) + 1 ;

239

}

3.3

Przykład użycia

Listing 3: Przykład użycia

#include<s t d i o . h>

#include<m a l l o c . h>

#include ” b s t . h”

i n t main ( ) {

BST ∗ t r e e = NULL ;

t r e e = add ( t r e e , 1 5 ) ;

t r e e = add ( t r e e , 6 ) ;

t r e e = add ( t r e e , 3 ) ;

t r e e = add ( t r e e , 7 ) ;

t r e e = add ( t r e e , 2 ) ;

t r e e = add ( t r e e , 4 ) ;

t r e e = add ( t r e e , 1 3 ) ;

t r e e = add ( t r e e , 9 ) ;

t r e e = add ( t r e e , 1 8 ) ;

t r e e = add ( t r e e , 1 7 ) ;

t r e e = add ( t r e e , 2 0 ) ;

p r i n t f ( ” i n o r d e r ( ) :

” ) ;

i n o r d e r ( t r e e ) ;

p r i n t f ( ” \ n p o s t o r d e r ( ) :

” ) ;

p o s t o r d e r ( t r e e ) ;

p r i n t f ( ” \ n p o s t o r d e r i n v e r s e ( ) :

” ) ;

p o s t o r d e r i n v e r s e ( t r e e ) ;

p r i n t f ( ” \ n p r e o r d e r ( ) :

” ) ;

p r e o r d e r ( t r e e ) ;

p r i n t f ( ” \ n s e a r c h ( 2 ) : ” ) ;

s e a r c h ( t r e e , 2 ) ;

p r i n t f ( ” \ n s e a r c h ( 7 ) : ” ) ;

s e a r c h ( t r e e , 7 ) ;

p r i n t f ( ” \ nmin ( 7 ) : ” ) ;

e c h o ( min ( t r e e ) ) ;

p r i n t f ( ”max ( 7 ) : ” ) ;

e c h o ( max ( t r e e ) ) ;

i n t n s t =15;

p r i n t f ( ” N a s t e p n i k %d : ” , n s t ) ;

e c h o ( n a s t e p n i k ( s e a r c h ( t r e e , n s t ) ) ) ;

p r i n t f ( ” P o p r z e d n i k %d : ” , n s t ) ;

e c h o ( p o p r z e d n i k ( s e a r c h ( t r e e , n s t ) ) ) ;

d e l ( t r e e , n s t ) ;

p r i n t f ( ”Waga drzewa : %d\n” , waga ( t r e e ) ) ;

p r i n t f ( ” Droga ( 1 7 , 2 0 ) : ” ) ;

t r a c e ( t r e e , 1 7 , 2 0 ) ;

p r i n t f ( ” \ nDroga ( 2 0 , 1 7 ) : ” ) ;

t r a c e ( t r e e , 2 0 , 1 7 ) ;

p r i n t f ( ” \ nDroga ( 2 0 , 2 6 ) : ” ) ;

t r a c e ( t r e e , 2 0 , 2 6 ) ;

p r i n t f ( ” \n” ) ;

return 0 ;

}

Document Outline