1 # This file is part of NIT ( http://www.nitlanguage.org ).
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at
7 # http://www.apache.org/licenses/LICENSE-2.0
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
15 # Binary Tree data-structure
16 # A binary tree is a tree data structure in which each node has at most two children
17 # (referred to as the left child and the right child).
18 # In a binary tree, the degree of each node can be at most two.
19 # Binary trees are used to implement binary search trees and binary heaps,
20 # and are used for efficient searching and sorting.
29 # * node.left.key < node.key
30 # * node.right.key > node.key
31 # * no duplicates allowed
34 # * search average O(lg n) worst O(n)
35 # * insert average O(lg n) worst O(n)
36 # * delete average O(lg n) worst O(n)
39 # var tree = new BinTreeMap[Int, String]
41 # assert tree.min == "n1"
42 class BinTreeMap[K
: Comparable, E
]
45 redef type N
: BinTreeNode[K
, E
]
48 private var first_node
: nullable BinTreeNode[K
, E
] = null
49 private var last_node
: nullable BinTreeNode[K
, E
] = null
51 # O(n) in worst case, average is O(h) with h: tree height
53 # var tree = new BinTreeMap[Int, String]
54 # assert tree.is_empty
56 # assert not tree.is_empty
57 redef fun is_empty
do return root
== null
59 # O(n) in worst case, average is O(h) with h: tree height
61 # var tree = new BinTreeMap[Int, String]
62 # assert not tree.has_key(1)
63 # for i in [4, 2, 1, 5, 3] do tree[i] = "n{i}"
64 # assert not tree.has_key(0)
65 # assert tree.has_key(2)
66 # assert not tree.has_key(6)
67 redef fun has_key
(key
: K
): Bool do
68 if is_empty
then return false
69 var res
= search_down
(root
.as(not null), key
)
77 private var cache_node
: nullable N
= null
79 # Get the node value associated to `key`
80 # O(n) in worst case, average is O(h) with h: tree height
82 # var tree = new BinTreeMap[Int, String]
83 # for i in [4, 2, 1, 5, 3] do tree[i] = "n{i}"
84 # assert tree.has_key(1)
85 # assert tree[1] == "n1"
86 # assert tree.has_key(1)
87 # assert tree[2] == "n2"
88 redef fun [](key
: K
): E
do
89 assert not_empty
: not is_empty
90 if cache_node
!= null and cache_node
.key
== key
then return cache_node
.value
91 var res
= search_down
(root
.as(not null), key
)
92 assert has_key
: res
!= null
96 protected fun search_down
(from
: N
, key
: K
): nullable N
do
97 var cmp
= key
<=> from
.key
98 if cmp
== 0 then return from
99 if from
.left
!= null and cmp
< 0 then
100 return search_down
(from
.left
.as(not null), key
)
101 else if from
.right
!= null then
102 return search_down
(from
.right
.as(not null), key
)
107 # Get the node with the minimum key
108 # O(n) in worst case, average is O(h) with h: tree height
110 # var tree = new BinTreeMap[Int, String]
111 # for i in [4, 2, 1, 5, 3] do tree[i] = "n{i}"
112 # assert tree.min == "n1"
114 assert not_empty
: root
!= null
115 return min_from
(root
.as(not null)).value
118 protected fun min_from
(node
: N
): N
do
119 if node
.left
== null then return node
120 return min_from
(node
.left
.as(not null))
123 # Get the node with the maximum key
124 # O(n) in worst case, average is O(h) with h: tree height
126 # var tree = new BinTreeMap[Int, String]
127 # for i in [4, 2, 1, 5, 3, 6, 7, 8] do tree[i] = "n{i}"
128 # assert tree.max == "n8"
130 assert not_empty
: root
!= null
131 return max_from
(root
.as(not null)).value
134 protected fun max_from
(node
: N
): N
do
135 if node
.right
== null then return node
136 return max_from
(node
.right
.as(not null))
139 # Insert a new node in tree using `key` and `item`
140 # O(n) in worst case, average is O(h) with h: tree height
142 # var tree = new BinTreeMap[Int, String]
144 # assert tree.max == "n1"
146 # assert tree.max == "n3"
147 redef fun []=(key
, item
) do
148 insert_node
(new BinTreeNode[K
, E
](key
, item
))
151 protected fun insert_node
(node
: N
) do
156 shift_down
(root
.as(not null), node
)
158 if first_node
== null then
161 if last_node
!= null then
162 last_node
.next
= node
163 node
.prev
= last_node
168 # Push down the `node` in tree from a specified `from` index
169 protected fun shift_down
(from
, node
: N
) do
170 var cmp
= node
.key
<=> from
.key
172 if from
.left
== null then
176 shift_down
(from
.left
.as(not null), node
)
179 if from
.right
== null then
183 shift_down
(from
.right
.as(not null), node
)
188 # Delete node at `key` (also return the deleted node value)
189 # O(n) in worst case, average is O(h) with h: tree height
191 # var tree = new BinTreeMap[Int, String]
193 # assert tree.max == "n1"
195 # assert tree.max == "n3"
197 # assert tree.max == "n1"
198 fun delete
(key
: K
): nullable E
do
199 assert is_empty
: root
!= null
201 var node
= search_down
(root
.as(not null), key
)
202 if node
== null then return null
203 if node
.left
== null then
204 transplant
(node
, node
.right
)
205 else if node
.right
== null then
206 transplant
(node
, node
.left
)
208 var min
= min_from
(node
.right
.as(not null))
209 if min
.parent
!= node
then
210 transplant
(min
, min
.right
)
211 min
.right
= node
.right
212 min
.right
.parent
= min
214 transplant
(node
, min
)
216 min
.left
.parent
= min
218 if first_node
== node
then
221 if last_node
== node
then
222 last_node
= node
.prev
223 last_node
.next
= null
225 node
.prev
.next
= node
.next
226 node
.next
.prev
= node
.prev
231 # Swap a `node` with the `other` in this Tree
232 # note: Nodes parents are updated, children still untouched
233 protected fun transplant
(node
, other
: nullable N
) do
234 if node
== null then return
235 if node
.parent
== null then
237 else if node
== node
.parent
.left
then
238 node
.parent
.left
= other
240 node
.parent
.right
= other
242 if other
!= null then other
.parent
= node
.parent
245 # Perform left rotation on `node`
253 protected fun rotate_left
(node
: N
) do
256 if y
.left
!= null then
259 y
.parent
= node
.parent
260 if node
.parent
== null then
262 else if node
== node
.parent
.left
then
265 node
.parent
.right
= y
271 # Perform right rotation on `node`
279 protected fun rotate_right
(node
: N
) do
282 if y
.right
!= null then
283 y
.right
.parent
= node
285 y
.parent
= node
.parent
286 if node
.parent
== null then
288 else if node
== node
.parent
.right
then
289 node
.parent
.right
= y
297 # Sort the tree into an array
300 # var tree = new BinTreeMap[Int, String]
301 # for i in [4, 2, 1, 5, 3] do tree[i] = "n{i}"
302 # assert tree.sort == ["n1", "n2", "n3", "n4", "n5"]
303 fun sort
: Array[E
] do
304 var sorted
= new Array[E
]
305 if root
== null then return sorted
306 sort_down
(root
.as(not null), sorted
)
310 protected fun sort_down
(node
: N
, sorted
: Array[E
]) do
311 if node
.left
!= null then sort_down
(node
.left
.as(not null), sorted
)
312 sorted
.add
(node
.value
)
313 if node
.right
!= null then sort_down
(node
.right
.as(not null), sorted
)
318 if root
== null then return "[]"
319 return "[{print_tree(root)}]"
322 protected fun print_tree
(node
: N
): String do
323 var s
= new FlatBuffer
325 if node
.left
!= null then s
.append
(print_tree
(node
.left
.as(not null)))
326 if node
.right
!= null then s
.append
(print_tree
(node
.right
.as(not null)))
330 redef fun show_dot
do
331 assert not_empty
: root
!= null
332 var f
= new OProcess("dot", "-Txlib")
333 f
.write
"digraph \{\n"
334 dot_down
(root
.as(not null), f
)
339 protected fun dot_down
(node
: N
, f
: OProcess) do
340 if node
.left
!= null then dot_down
(node
.left
.as(not null), f
)
342 if node
.right
!= null then dot_down
(node
.right
.as(not null), f
)
347 # var tree = new BinTreeMap[Int, String]
348 # assert tree.length == 0
349 # for i in [4, 2, 1, 5, 3] do tree[i] = "n{i}"
350 # assert tree.length == 5
351 redef fun length
do return len
353 # Nodes are iterated in the same order in which they were added to the tree.
356 # var tree = new BinTreeMap[Int, String]
357 # for i in [4, 2, 1, 5, 3] do tree[i] = "n{i}"
358 # var keys = new Array[Int]
359 # for k, v in tree do
362 # assert keys == [4, 2, 1, 5, 3]
363 redef fun iterator
do return new BinTreeMapIterator[K
, E
](self)
366 # TreeNode used by BinTree
367 class BinTreeNode[K
: Comparable, E
]
370 private var prev
: nullable BinTreeNode[K
, E
]
371 private var next
: nullable BinTreeNode[K
, E
]
373 redef type SELF: BinTreeNode[K
, E
]
375 init(key
: K
, item
: E
) do
379 private var left_node
: nullable SELF = null
381 # `left` tree node child (null if node has no left child)
382 fun left
: nullable SELF do return left_node
384 # set `left` child for this node (or null if left no child)
385 # ENSURE: node.key < key (only if node != null)
386 fun left
=(node
: nullable SELF) do
387 #assert node != null implies node.key < key
391 private var right_node
: nullable SELF = null
393 # `right` tree node child (null if node has no right child)
394 fun right
: nullable SELF do return right_node
396 # set `right` child for this node (or null if right no child)
397 # ENSURE: node.key < key (only if node != null)
398 fun right
=(node
: nullable SELF) do
399 #assert node != null implies node.key > key
403 # `parent` of the `parent` of this node (null if root)
404 fun grandparent
: nullable SELF do
405 if parent
== null then
412 # Other child of the `grandparent`
413 # `left` or `right` depends on the position of the current node against its parent
414 fun uncle
: nullable SELF do
419 if parent
== g
.left
then
427 # Other child of the parent
428 # `left` or `right` depends on the position of the current node against its parent
429 fun sibling
: nullable SELF do
430 if parent
== null then
432 else if self == parent
.left
then
434 else if self == parent
.right
then
441 redef fun to_s
do return "\{{key}: {value or else ""}\}"
444 private class BinTreeMapIterator[K
: Comparable, E
]
445 super MapIterator[K
, E
]
447 var current
: nullable BinTreeNode[K
, E
]
449 init(tree
: BinTreeMap[K
, E
]) do
450 current
= tree
.first_node
453 redef fun is_ok
do return not current
== null
454 redef fun next
do current
= current
.next
455 redef fun item
do return current
.value
456 redef fun key
do do return current
.key