Merge pull request #766 from goerch/master

Fix type instabilities in AVL, RB and splay tree

Author: oxinabox

src/avl_tree.jl

@@ -14,6 +14,9 @@ end
 
 AVLTreeNode(d) = AVLTreeNode{Any}(d)
 
+Base.setproperty!(x::AVLTreeNode{T}, f::Symbol, v) where {T} =
+    setfield!(x, f, v)
+
 AVLTreeNode_or_null{T} = Union{AVLTreeNode{T}, Nothing}
 
 mutable struct AVLTree{T}
@@ -27,7 +30,7 @@ AVLTree() = AVLTree{Any}()
 
 Base.length(tree::AVLTree) = tree.count
 
-get_height(node::Union{AVLTreeNode, Nothing}) = (node == nothing) ? 0 : node.height
+get_height(node::Union{AVLTreeNode, Nothing}) = (node == nothing) ? Int8(0) : node.height
 
 # balance is the difference of height between leftChild and rightChild of a node.
 function get_balance(node::Union{AVLTreeNode, Nothing})
@@ -40,25 +43,25 @@ end
 
 # computes the height of the subtree, which basically is
 # one added the maximum of the height of the left subtree and right subtree
-compute_height(node::AVLTreeNode) = 1 + max(get_height(node.leftChild), get_height(node.rightChild))
+compute_height(node::AVLTreeNode) = Int8(1) + max(get_height(node.leftChild), get_height(node.rightChild))
 
-get_subsize(node::AVLTreeNode_or_null) = (node == nothing) ? 0 : node.subsize
+get_subsize(node::AVLTreeNode_or_null) = (node == nothing) ? Int32(0) : node.subsize
 
 # compute the subtree size
 function compute_subtree_size(node::AVLTreeNode_or_null)
     if node == nothing
-        return 0
+        return Int32(0)
     else
         L = get_subsize(node.leftChild)
         R = get_subsize(node.rightChild)
-        return (L + R + 1)
+        return (L + R + Int32(1))
     end
 end
 
 """
     left_rotate(node_x::AVLTreeNode)
 
-Performs a left-rotation on `node_x`, updates height of the nodes, and returns the rotated node. 
+Performs a left-rotation on `node_x`, updates height of the nodes, and returns the rotated node.
 """
 function left_rotate(z::AVLTreeNode)
     y = z.rightChild
@@ -75,7 +78,7 @@ end
 """
     right_rotate(node_x::AVLTreeNode)
 
-Performs a right-rotation on `node_x`, updates height of the nodes, and returns the rotated node. 
+Performs a right-rotation on `node_x`, updates height of the nodes, and returns the rotated node.
 """
 function right_rotate(z::AVLTreeNode)
     y = z.leftChild
@@ -90,9 +93,9 @@ function right_rotate(z::AVLTreeNode)
 end
 
 """
-   minimum_node(tree::AVLTree, node::AVLTreeNode) 
+   minimum_node(tree::AVLTree, node::AVLTreeNode)
 
-Returns the AVLTreeNode with minimum value in subtree of `node`. 
+Returns the AVLTreeNode with minimum value in subtree of `node`.
 """
 function minimum_node(node::Union{AVLTreeNode, Nothing})
     while node != nothing && node.leftChild != nothing
@@ -107,60 +110,60 @@ function search_node(tree::AVLTree{K}, d::K) where K
     while node != nothing && node.data != nothing && node.data != d
 
         prev = node
-        if d < node.data 
+        if d < node.data
             node = node.leftChild
         else
             node = node.rightChild
         end
     end
-    
+
     return (node == nothing) ? prev : node
 end
 
-function Base.haskey(tree::AVLTree{K}, d::K) where K 
+function Base.haskey(tree::AVLTree{K}, d::K) where K
     (tree.root == nothing) && return false
     node = search_node(tree, d)
     return (node.data == d)
 end
 
 Base.in(key, tree::AVLTree) = haskey(tree, key)
 
-function Base.insert!(tree::AVLTree{K}, d::K) where K
+function insert_node(node::Nothing, key::K) where K
+    return AVLTreeNode{K}(key)
+end
+function insert_node(node::AVLTreeNode{K}, key::K) where K
+    if key < node.data
+        node.leftChild = insert_node(node.leftChild, key)
+    else
+        node.rightChild = insert_node(node.rightChild, key)
+    end
+
+    node.subsize = compute_subtree_size(node)
+    node.height = compute_height(node)
+    balance = get_balance(node)
 
-    function insert_node(node::Union{AVLTreeNode, Nothing}, key)
-        if node == nothing
-            return AVLTreeNode{K}(key)
-        elseif key < node.data
-            node.leftChild = insert_node(node.leftChild, key)
+    if balance > 1
+        if key < node.leftChild.data
+            return right_rotate(node)
         else
-            node.rightChild = insert_node(node.rightChild, key)
-        end
-        
-        node.subsize = compute_subtree_size(node)
-        node.height = compute_height(node)
-        balance = get_balance(node)
-        
-        if balance > 1
-            if key < node.leftChild.data
-                return right_rotate(node)
-            else
-                node.leftChild = left_rotate(node.leftChild)
-                return right_rotate(node)
-            end
+            node.leftChild = left_rotate(node.leftChild)
+            return right_rotate(node)
         end
+    end
 
-        if balance < -1
-            if key > node.rightChild.data
-                return left_rotate(node)
-            else
-                node.rightChild = right_rotate(node.rightChild)
-                return left_rotate(node)
-            end
+    if balance < -1
+        if key > node.rightChild.data
+            return left_rotate(node)
+        else
+            node.rightChild = right_rotate(node.rightChild)
+            return left_rotate(node)
         end
-
-        return node
     end
 
+    return node
+end
+
+function Base.insert!(tree::AVLTree{K}, d::K) where K
     haskey(tree, d) && return tree
 
     tree.root = insert_node(tree.root, d)
@@ -173,55 +176,54 @@ function Base.push!(tree::AVLTree{K}, key0) where K
     insert!(tree, key)
 end
 
-function Base.delete!(tree::AVLTree{K}, d::K) where K
-
-    function delete_node!(node::Union{AVLTreeNode, Nothing}, key)
-        if key < node.data
-            node.leftChild = delete_node!(node.leftChild, key)
-        elseif key > node.data
-            node.rightChild = delete_node!(node.rightChild, key)
+function delete_node!(node::AVLTreeNode{K}, key::K) where K
+    if key < node.data
+        node.leftChild = delete_node!(node.leftChild, key)
+    elseif key > node.data
+        node.rightChild = delete_node!(node.rightChild, key)
+    else
+        if node.leftChild == nothing
+            result = node.rightChild
+            return result
+        elseif node.rightChild == nothing
+            result = node.leftChild
+            return result
         else
-            if node.leftChild == nothing
-                result = node.rightChild
-                return result
-            elseif node.rightChild == nothing
-                result = node.leftChild
-                return result
-            else 
-                result = minimum_node(node.rightChild)
-                node.data = result.data
-                node.rightChild = delete_node!(node.rightChild, result.data)
-            end 
+            result = minimum_node(node.rightChild)
+            node.data = result.data
+            node.rightChild = delete_node!(node.rightChild, result.data)
         end
-        
-        node.subsize = compute_subtree_size(node)
-        node.height = compute_height(node)
-        balance = get_balance(node)
-
-        if balance > 1
-            if get_balance(node.leftChild) >= 0
-                return right_rotate(node)
-            else
-                node.leftChild = left_rotate(node.leftChild)
-                return right_rotate(node)
-            end
+    end
+
+    node.subsize = compute_subtree_size(node)
+    node.height = compute_height(node)
+    balance = get_balance(node)
+
+    if balance > 1
+        if get_balance(node.leftChild) >= 0
+            return right_rotate(node)
+        else
+            node.leftChild = left_rotate(node.leftChild)
+            return right_rotate(node)
         end
+    end
 
-        if balance < -1
-            if get_balance(node.rightChild) <= 0
-                return left_rotate(node)
-            else
-                node.rightChild = right_rotate(node.rightChild)
-                return left_rotate(node)
-            end
-        end 
-        
-        return node
+    if balance < -1
+        if get_balance(node.rightChild) <= 0
+            return left_rotate(node)
+        else
+            node.rightChild = right_rotate(node.rightChild)
+            return left_rotate(node)
+        end
     end
 
+    return node
+end
+
+function Base.delete!(tree::AVLTree{K}, d::K) where K
     # if the key is not in the tree, do nothing and return the tree
     !haskey(tree, d) && return tree
-    
+
     # if the key is present, delete it from the tree
     tree.root = delete_node!(tree.root, d)
     tree.count -= 1
@@ -244,12 +246,12 @@ function sorted_rank(tree::AVLTree{K}, key::K) where K
         else
             node = node.leftChild
         end
-    end 
+    end
     rank += (1 + get_subsize(node.leftChild))
     return rank
 end
 
-function Base.getindex(tree::AVLTree{K}, ind::Integer) where K 
+function Base.getindex(tree::AVLTree{K}, ind::Integer) where K
     @boundscheck (1 <= ind <= tree.count) || throw(BoundsError("$ind should be in between 1 and $(tree.count)"))
     function traverse_tree(node::AVLTreeNode_or_null, idx)
         if (node != nothing)
@@ -263,6 +265,6 @@ function Base.getindex(tree::AVLTree{K}, ind::Integer) where K
             end
         end
     end
-    value = traverse_tree(tree.root, ind) 
+    value = traverse_tree(tree.root, ind)
     return value
-end
+end

src/red_black_tree.jl

@@ -17,6 +17,9 @@ end
 RBTreeNode() = RBTreeNode{Any}()
 RBTreeNode(d) = RBTreeNode{Any}(d)
 
+Base.setproperty!(x::RBTreeNode{K}, f::Symbol, v) where {K} =
+    setfield!(x, f, v)
+
 function create_null_node(K::Type)
     node = RBTreeNode{K}()
     node.color = false

src/splay_tree.jl

@@ -11,12 +11,15 @@ end
 SplayTreeNode(d) = SplayTreeNode{Any}(d)
 SplayTreeNode() = SplayTreeNode{Any}()
 
+Base.setproperty!(x::SplayTreeNode{K}, f::Symbol, v) where {K} =
+    setfield!(x, f, v)
+
 mutable struct SplayTree{K}
     root::Union{SplayTreeNode{K}, Nothing}
     count::Int
 
     SplayTree{K}() where K = new{K}(nothing, 0)
-end 
+end
 
 Base.length(tree::SplayTree) = tree.count
 
@@ -41,7 +44,7 @@ function left_rotate!(tree::SplayTree, node_x::SplayTreeNode)
         node_y.leftChild = node_x
     end
     node_x.parent = node_y
-end    
+end
 
 function right_rotate!(tree::SplayTree, node_x::SplayTreeNode)
     node_y = node_x.leftChild
@@ -59,7 +62,7 @@ function right_rotate!(tree::SplayTree, node_x::SplayTreeNode)
     end
     node_y.rightChild = node_x
     node_x.parent = node_y
-end 
+end
 
 # The splaying operation moves node_x to the root of the tree using the series of rotations.
 function splay!(tree::SplayTree, node_x::SplayTreeNode)
@@ -71,7 +74,7 @@ function splay!(tree::SplayTree, node_x::SplayTreeNode)
             if node_x == parent.leftChild
                 # zig rotation
                 right_rotate!(tree, node_x.parent)
-            else 
+            else
                 # zag rotation
                 left_rotate!(tree, node_x.parent)
             end
@@ -104,7 +107,7 @@ function maximum_node(node::Union{SplayTreeNode, Nothing})
     return node
 end
 
-# Join operations joins two trees S and T 
+# Join operations joins two trees S and T
 # All the items in S are smaller than the items in T.
 # This is a two-step process.
 # In the first step, splay the largest node in S. This moves the largest node to the root node.
@@ -157,10 +160,10 @@ function Base.delete!(tree::SplayTree{K}, d::K) where K
     x = search_node(tree, d)
     (x == nothing) && return tree
     t = nothing
-    s = nothing 
-    
+    s = nothing
+
     splay!(tree, x)
-    
+
     if x.rightChild !== nothing
         t = x.rightChild
         t.parent = nothing
@@ -211,7 +214,7 @@ function Base.push!(tree::SplayTree{K}, d0) where K
     return tree
 end
 
-function Base.getindex(tree::SplayTree{K}, ind) where K 
+function Base.getindex(tree::SplayTree{K}, ind) where K
     @boundscheck (1 <= ind <= tree.count) || throw(KeyError("$ind should be in between 1 and $(tree.count)"))
     function traverse_tree_inorder(node::Union{SplayTreeNode, Nothing})
         if (node != nothing)
@@ -222,6 +225,6 @@ function Base.getindex(tree::SplayTree{K}, ind) where K
             return K[]
         end
     end
-    arr = traverse_tree_inorder(tree.root) 
+    arr = traverse_tree_inorder(tree.root)
     return @inbounds arr[ind]
 end

test/runtests.jl

@@ -5,7 +5,8 @@ using Serialization
 
 import DataStructures: IntSet
 
-@test [] == detect_ambiguities(Base, Core, DataStructures)
+@test [] == detect_ambiguities(Core, DataStructures)
+@test [] == detect_ambiguities(Base, DataStructures)
 
 tests = ["deprecations",
          "int_set",
@@ -34,7 +35,7 @@ tests = ["deprecations",
          "dibit_vector",
          "swiss_dict",
          "avl_tree",
-         "red_black_tree", 
+         "red_black_tree",
          "splay_tree"
         ]