export RBTree and deploy docs

Author: eulerkochy

docs/make.jl

@@ -25,6 +25,7 @@ makedocs(
         "intset.md",
         "sorted_containers.md",
         "dibit_vector.md",
+        "red_black_tree.md",
     ],
     modules = [DataStructures],
     format = Documenter.HTML()

docs/src/index.md

@@ -22,6 +22,7 @@ This package implements a variety of data structures, including
 -   DataStructures.IntSet
 -   SparseIntSet
 -   DiBitVector
+-   Red Black Tree
 
 ## Contents
 
@@ -46,6 +47,7 @@ Pages = [
     "intset.md",
     "sorted_containers.md",
     "sparse_int_set.md",
-    "dibit_vector.md"
+    "dibit_vector.md",
+    "red_black_tree.md"
 ]
 ```

docs/src/red_black_tree.md

@@ -0,0 +1,34 @@
+```@meta
+DocTestSetup = :(using DataStructures)
+```
+
+# Red Black Tree
+
+The `RBTree` type is an implementation of Red Black Tree in Julia. It is a self-balancing binary search tree with an extra bit of information, the color, in each of its node. Operations such as search, insert and delete can be done in `O(log n)` complexity, where `n` is the number of nodes in the `RBTree`.
+
+Examples:
+
+```jldoctest
+julia> tree = RBTree{Int}();
+
+julia> for k in 1:2:20
+           push!(tree, k)
+       end
+
+julia> haskey(tree, 3)
+true
+
+julia> getindex(tree, 4)
+7
+
+julia> for k in 1:2:10
+           delete!(tree, k)
+       end
+
+julia> haskey(tree, 5)
+false
+```
+
+```@meta
+DocTestSetup = nothing
+```

src/DataStructures.jl

@@ -61,6 +61,8 @@ module DataStructures
 
     export DiBitVector
 
+    export RBTree, search_node, minimum_node
+
     export findkey
 
     include("delegate.jl")

src/red_black_tree.jl

@@ -31,7 +31,7 @@ mutable struct RBTree{K}
     function RBTree{K}() where K 
         rb = new()
         rb.nil = create_null_node(K)
-        rb.root = Ref(rb.nil)[]
+        rb.root = rb.nil
         rb.count = 0
         return rb
     end
@@ -50,7 +50,7 @@ search_node(tree, key)
 
 function search_node(tree::RBTree{K}, d::K) where K
     node = tree.root
-    while node != tree.nil && d != node.data
+    while node !== tree.nil && d != node.data
         if d < node.data
             node = node.leftChild
         else
@@ -81,7 +81,7 @@ function insert_node!(tree::RBTree, node::RBTreeNode)
     node_y = nothing
     node_x = tree.root
 
-    while node_x != tree.nil
+    while node_x !== tree.nil
         node_y = node_x
         if node.data < node_x.data
             node_x = node_x.leftChild
@@ -108,7 +108,7 @@ Performs a left-rotation on `node_x` and updates `tree.root`, if required.
 function left_rotate!(tree::RBTree, node_x::RBTreeNode)
     node_y = node_x.rightChild
     node_x.rightChild = node_y.leftChild
-    if node_y.leftChild != tree.nil
+    if node_y.leftChild !== tree.nil
         node_y.leftChild.parent = node_x
     end
     node_y.parent = node_x.parent
@@ -131,7 +131,7 @@ Performs a right-rotation on `node_x` and updates `tree.root`, if required.
 function right_rotate!(tree::RBTree, node_x::RBTreeNode)
     node_y = node_x.leftChild
     node_x.leftChild = node_y.rightChild
-    if node_y.rightChild != tree.nil
+    if node_y.rightChild !== tree.nil
         node_y.rightChild.parent = node_x
     end
     node_y.parent = node_x.parent
@@ -327,8 +327,8 @@ end
 Returns the RBTreeNode with minimum value in subtree of `node`. 
 """
 function minimum_node(tree::RBTree, node::RBTreeNode)
-    (node == tree.nil) && return node
-    while node.leftChild != tree.nil
+    (node === tree.nil) && return node
+    while node.leftChild !== tree.nil
         node = node.leftChild
     end
     return node
@@ -345,7 +345,7 @@ function Base.delete!(tree::RBTree{K}, d::K) where K
     z = tree.nil
     node = tree.root
 
-    while node != tree.nil
+    while node !== tree.nil
         if node.data == d
             z = node
         end
@@ -357,15 +357,15 @@ function Base.delete!(tree::RBTree{K}, d::K) where K
         end
     end
 
-    (z == tree.nil) && return tree
+    (z === tree.nil) && return tree
 
     y = z
     y_original_color = y.color
     x = RBTreeNode{K}()
-    if z.leftChild == tree.nil
+    if z.leftChild === tree.nil
         x = z.rightChild
         rb_transplant(tree, z, z.rightChild)
-    elseif z.rightChild == tree.nil
+    elseif z.rightChild === tree.nil
         x = z.leftChild
         rb_transplant(tree, z, z.leftChild)
     else
@@ -404,7 +404,7 @@ getindex(tree, ind)
 function Base.getindex(tree::RBTree{K}, ind) where K 
     @boundscheck (1 <= ind <= tree.count) || throw(ArgumentError("$ind should be in between 1 and $(tree.count)"))
     function traverse_tree_inorder(node::RBTreeNode{K}) where K
-        if (node != tree.nil)
+        if (node !== tree.nil)
             left = traverse_tree_inorder(node.leftChild)
             right = traverse_tree_inorder(node.rightChild)
             append!(push!(left, node.data), right)

test/test_red_black_tree.jl

@@ -1,4 +1,3 @@
-include("../src/red_black_tree.jl")
 @testset "RBTree" begin
     @testset "inserting values" begin
         t = RBTree{Int}()
@@ -41,7 +40,6 @@ include("../src/red_black_tree.jl")
         end
 
         @test length(t) == 100
-
     end
 
     @testset "handling different cases of delete!" begin