updating abovebelow to prevnext to be more generally descriptive. Also accepts the key, functions like an advanced search now. fixed tests using @inferred Nothing.

Author: souma4

src/binarytree.jl

@@ -166,44 +166,40 @@ end
 
 maxnode(node::Nothing) = nothing
 
-function abovebelow(tree::BinaryNode, x::BinaryNode)
-  above, below = nothing, nothing
-  current = tree
+function prevnext(tree::BinaryTree, k)
+  prev, next = nothing, nothing
+  current = root(tree)
   # Traverse from the root to the target node, updating candidates.
-  while !isnothing(current) && key(current) != key(x)
-    if key(x) < key(current)
-      # current is a potential above (successor)
-      above = current
+  while !isnothing(current) && key(current) != k
+    if k < key(current)
+      # current is a potential next (successor)
+      next = current
       current = left(current)
-    else # x.key > current.key
-      # current is a potential below (predecessor)
-      below = current
+    else # k.key > current.key
+      # current is a potential previous (predecessor)
+      prev = current
       current = right(current)
     end
   end
 
   # If the node wasn't found, return the best candidate values
   if isnothing(current)
-    return (above, below)
+    return (prev, next)
   end
 
   # Found the node with key equal to x.key.
-  # Now, if there is a left subtree, the true below (predecessor) is the maximum in that subtree.
+  # Now, if there is a left subtree, the true previous (predecessor) is the maximum in that subtree.
   if !isnothing(left(current))
-    below = maxnode(left(current))
+    prev = maxnode(left(current))
   end
-  # Similarly, if there is a right subtree, the true above (successor) is the minimum in that subtree.
+  # Similarly, if there is a right subtree, the true next (successor) is the minimum in that subtree.
   if !isnothing(right(current))
-    above = minnode(right(current))
+    next = minnode(right(current))
   end
 
-  (above, below)
+  (prev, next)
 end
 
-function abovebelow(tree::BinaryTree, x::BinaryNode)
-  abovebelow(root(tree), x)
-end
-
-function abovebelow(tree, x::Nothing)
+function prevnext(tree::BinaryTree, k::Nothing)
   (nothing, nothing)
 end

test/runtests.jl

@@ -230,21 +230,18 @@ const BT = BinaryTrees
     BT.insert!(tree, 6, 40)
     @test BT.key(BT.minnode(tree)) == 0
     @test BT.key(BT.maxnode(tree)) == 6
-    @test BT.abovebelow(tree, BT.AVLNode(0, 5))[2] == nothing
-    @test BT.key.(BT.abovebelow(tree, BT.AVLNode(2, 10))) == (3, 1)
-    @test BT.key.(BT.abovebelow(BT.root(tree), BT.AVLNode(2, 10))) == (3, 1)
-    @test BT.key.(BT.abovebelow(tree, BT.AVLNode(5, 30))) == (6, 4)
-    @test BT.abovebelow(tree, nothing) == (nothing, nothing)
-    @test BT.abovebelow(BT.root(tree), nothing) == (nothing, nothing)
+    @test BT.prevnext(tree, 0)[1] == nothing
+    @test BT.key.(BT.prevnext(tree, 2)) == (1, 3)
+    @test BT.key.(BT.prevnext(tree, 5)) == (4, 6)
+    @test BT.prevnext(tree, nothing) == (nothing, nothing)
 
     # type stability
     tree = AVLTree{Int,Int}()
     @inferred BT.insert!(tree, 2, 20)
     @inferred BT.insert!(tree, 1, 10)
     @inferred BT.insert!(tree, 3, 30)
-    @inferred BT.minnode(tree)
-    @inferred BT.maxnode(tree)
-    @inferred BT.abovebelow(tree, BT.AVLNode(2, 20))
+    @inferred Nothing BT.minnode(tree)
+    @inferred Nothing BT.maxnode(tree)
     @inferred Nothing BT.search(tree, 2)
     @inferred Nothing BT.search(tree, 1)
     @inferred Nothing BT.search(tree, 3)
@@ -255,6 +252,8 @@ const BT = BinaryTrees
     @inferred BT.insert!(tree, 2)
     @inferred BT.insert!(tree, 1)
     @inferred BT.insert!(tree, 3)
+    @inferred Nothing BT.minnode(tree)
+    @inferred Nothing BT.maxnode(tree)
     @inferred Nothing BT.search(tree, 2)
     @inferred Nothing BT.search(tree, 1)
     @inferred Nothing BT.search(tree, 3)
@@ -265,6 +264,8 @@ const BT = BinaryTrees
     @inferred BT.insert!(tree, "key2", 2)
     @inferred BT.insert!(tree, "key1", 1)
     @inferred BT.insert!(tree, "key3", 3)
+    @inferred Nothing BT.minnode(tree)
+    @inferred Nothing BT.maxnode(tree)
     @inferred Nothing BT.search(tree, "key2")
     @inferred Nothing BT.search(tree, "key1")
     @inferred Nothing BT.search(tree, "key3")
@@ -275,6 +276,8 @@ const BT = BinaryTrees
     @inferred BT.insert!(tree, (0, 1, 0), 2)
     @inferred BT.insert!(tree, (0, 0, 1), 1)
     @inferred BT.insert!(tree, (1, 0, 0), 3)
+    @inferred Nothing BT.minnode(tree)
+    @inferred Nothing BT.maxnode(tree)
     @inferred Nothing BT.search(tree, (0, 1, 0))
     @inferred Nothing BT.search(tree, (0, 0, 1))
     @inferred Nothing BT.search(tree, (1, 0, 0))