binary tree not complete, there is an error when convert

Author: kurt-steiner

Project.toml

@@ -1,4 +1,4 @@
-name = "LinkedList"
+name = "DataStructure"
 uuid = "3e022a7e-7250-4727-bf30-41362114d8c7"
 authors = ["steiner <[email protected]>"]
 version = "0.1.0"

src/DataStructure.jl

@@ -0,0 +1,7 @@
+module DataStructure
+
+export LinkedList, BinaryTree, BadOperationException
+include("linkedlist/LinkedList.jl")
+include("binarytree/BinaryTree.jl")
+include("exceptions.jl")
+end

src/binarytree/BinaryTree.jl

@@ -0,0 +1,86 @@
+module BinaryTree
+import Base:(==), iterate, eltype, show, insert!, 
+    keys, contains, length, popat!, replace!, filter, haskey,
+    convert
+
+export BinarySearchTree, search, AbstractBinaryTreeNode, AbstractBinaryTree
+using DataStructure.LinkedList
+
+abstract type AbstractBinaryTree end
+
+include("treenodes.jl")
+include("binarysearchtree.jl")
+
+eltype(::BinarySearchTree{T}) where T = T
+eltype(::Type{Base.Iterators.Filter{F, V}}) where {F, V} = eltype(V)
+
+length(tree::AbstractBinaryTree) = tree.length
+
+function iterate(tree::AbstractBinaryTree)
+    node = tree.root
+
+    if node === treenil
+        return nothing
+    end
+
+    queue = List(AbstractBinaryTreeNode)
+
+    if hasleft(node)
+        push!(queue, left(node))
+    end
+
+    if hasright(node)
+        push!(queue, right(node))
+    end
+
+    return dataof(node), queue
+end
+
+function iterate(::AbstractBinaryTree, queue::List{<:AbstractBinaryTreeNode})
+    isempty(queue) && return nothing
+
+    current = first(queue)
+    if hasleft(current)
+        push!(queue, left(current))
+    end
+
+    if hasright(current)
+        push!(queue, right(current))
+    end
+
+    popfirst!(queue)
+    return dataof(current), queue
+end
+
+function show(io::IO, tree::AbstractBinaryTree)
+    for value in tree
+        print(io, value, " ")
+    end
+end
+
+function filter(pred::Function, tree::AbstractBinaryTree) 
+    Iterators.filter(pred, tree) |> collect
+end
+
+function search(value::T, tree::AbstractBinaryTree)::AbstractBinaryTreeNode where T
+    compare = tree.compare
+    current = tree.root
+    while current !== treenil
+        result = compare(value, dataof(current))
+        if result > 0
+            current = right(current)
+        elseif result < 0
+            current = left(current)
+        else
+            break
+        end
+    end
+
+    return if current === treenil
+        treenil
+    else
+        current
+    end
+end
+
+end

src/binarytree/binarysearchtree.jl

@@ -0,0 +1,12 @@
+mutable struct BinarySearchTree{T} <: AbstractBinaryTree
+    root::Union{BinaryTreeNil, BinaryTreeNode{T}}
+    compare::Function
+    length::Int
+end
+
+BinarySearchTree(T::DataType, compare::Function) = BinarySearchTree{T}(treenil, compare, 0)
+
+function insert!(tree::BinarySearchTree{T}, data::T) where T
+    tree.root = insertNode!(tree.root, data, tree.compare)
+    tree.length += 1
+end

src/binarytree/treenodes.jl

@@ -0,0 +1,225 @@
+abstract type AbstractBinaryTreeNode end
+abstract type AbstractBinaryTreeConsNode{T} <: AbstractBinaryTreeNode end
+
+struct BinaryTreeNil <: AbstractBinaryTreeNode end
+
+treenil = BinaryTreeNil()
+
+mutable struct BinaryTreeNode{T} <: AbstractBinaryTreeConsNode{T}
+    data::T
+    left::Union{BinaryTreeNode{T}, BinaryTreeNil}
+    right::Union{BinaryTreeNode{T}, BinaryTreeNil}
+end
+
+mutable struct AVLTreeNode{T} <: AbstractBinaryTreeConsNode{T}
+    data::T
+    left::Union{AVLTreeNode{T}, BinaryTreeNil}
+    right::Union{AVLTreeNode{T}, BinaryTreeNil}
+    height::Int
+end
+
+BinaryTreeNode(data::T) where T = BinaryTreeNode{T}(data, treenil, treenil)
+AVLTreeNode(data::T) where T = AVLTreeNode{T}(data, treenil, treenil)
+
+dataof(node::AbstractBinaryTreeConsNode) = node.data
+left(node::AbstractBinaryTreeConsNode) = node.left
+right(node::AbstractBinaryTreeConsNode) = node.right
+
+==(leftnode::AbstractBinaryTreeConsNode, rightnode::AbstractBinaryTreeConsNode) = dataof(leftnode) == dataof(rightnode) &&
+    left(leftnode) == left(rightnode) &&
+    right(leftnode) == right(rightnode)
+
+show(io::IO, ::BinaryTreeNil) = print(io, "treenil")
+show(io::IO, node::AbstractBinaryTreeConsNode) = print(io, "treenode: ", dataof(node))
+
+isleaf(node::AbstractBinaryTreeConsNode) = left(node) === treenil && right(node) === treenil
+hasleft(node::AbstractBinaryTreeConsNode) = left(node) !== treenil
+hasright(node::AbstractBinaryTreeConsNode) = right(node) !== treenil
+
+insertNode!(::BinaryTreeNil, data::T, compare::Function) where T = BinaryTreeNode(data)
+function insertNode!(node::AbstractBinaryTreeConsNode{T}, data::T, compare::Function) where T
+    if compare(data, dataof(node)) < 0
+        node.left = insertNode!(left(node), data, compare)
+    else
+        node.right = insertNode!(right(node), data, compare)
+    end
+
+    return node
+end
+
+iterate(::BinaryTreeNil) = nothing
+function iterate(node::AbstractBinaryTreeConsNode{T}) where T
+    queue = List(AbstractBinaryTreeNode{T})
+
+    if hasleft(node)
+        push!(queue, left(node))
+    end
+
+    if hasright(node)
+        push!(queue, right(node))
+    end
+
+    return node, queue
+end
+
+function itearte(::AbstractBinaryTreeConsNode{T}, queue::List{<:AbstractBinaryTreeNode}) where T
+    if isempty(queue)
+        return nothing
+    end
+
+    current = popfirst!(queue)
+    if hasleft(current)
+        push!(queue, left(current))
+    end
+
+    if hasright(current)
+        push!(queue, right(current))
+    end
+
+    return current, queue
+end
+
+function findNode(node::AbstractBinaryTreeConsNode, data::T, compare::Function)::AbstractBinaryTreeNode where T
+    backfather = node
+    status = 0
+    result = compare(dataof(node), data)
+
+    while node !== treenil
+        if result== 0
+            return backfather
+        end
+
+        backfather = node
+        if result > 0
+            node = left(node)
+            status = -1
+        else
+            node = right(node)
+            status = 1
+        end
+    end
+
+    return treenil
+end
+
+height(::BinaryTreeNil) = 0
+height(node::AVLTreeNode) = node.height
+balanceFactor(::BinaryTreeNil) = 0
+balanceFactor(node::AVLTreeNode) = height(left(node)) - height(right(node))
+
+function rotateLeftLeft!(node::AVLTreeNode)::AVLTreeNode
+    rightnode = right(node)
+    leftnode = left(rightnode)
+  
+    rightnode.left = node
+    node.right = leftnode
+  
+    node.height = max(height(left(node)), height(right(node))) + 1
+    rightnode.height = max(height(left(rightnode)), height(right(rightnode))) + 1
+  
+    return rightnode
+end
+
+function rotateRightRight!(node::AVLTreeNode)::AVLTreeNode
+    leftnode = left(node)
+    rightnode = right(leftnode)
+  
+    leftnode.right = node
+    node.left = rightnode
+  
+    node.height = max(height(left(node)), height(right(node))) + 1
+    leftnode.height = max(height(left(leftnode)), height(right(leftnode))) + 1
+  
+    return leftnode
+end
+
+function rotateLeftRight!(node::AVLTreeNode)::AVLTreeNode
+    node.left = rotateRightRight!(left(node))
+    return rotateLeftLeft!(node)
+end
+  
+function rotateRightLeft!(node::AVLTreeNode)::AVLTreeNode
+    node.right = rotateLeftLeft!(right(node))
+    return rotateRightRight!(node)
+end
+
+function rebalance!(node::AVLTreeNode)::AVLTreeNode
+    factor = balanceFactor(node)
+    if factor > 1 && balanceFactor(left(node)) > 0
+        return rotateRightRight!(node)
+    elseif factor > 1 && balanceFactor(left(node)) <= 0
+        return rotateLeftRight!(node)
+    elseif factor < -1 && balanceFactor(right(node)) <= 0
+        return rotateLeftLeft!(node)
+    elseif factor < -1 && balanceFactor(right(node)) > 0
+        return rotateRightLeft!(node)
+    else
+        return node
+    end
+end
+
+insertAVLNode!(::BinaryTreeNil, data::T, compare::Function) where T = AVLTreeNode(data)
+
+function insertAVLNode!(node::AVLTreeNode{T}, data::T, compare::Function)::AVLTreeNode{T} where T
+    result = compare(data, dataof(node))
+    if result > 0
+        node.right = insertAVLNode!(right(node), data, compare)
+    elseif result < 0
+        node.left = insertAVLNode!(left(node), data, compare)
+    else
+        return node
+    end
+
+    node.height = max(height(left(node)), height(right(node))) + 1
+    node = rebalance!(node)
+    return node
+end
+
+function deleteAVLNode!(node::AVLTreeNode{T}, data::T, compare::Function)::AVLTreeNode{T} where T
+    result = compare(data, dataof(node))
+
+    if result < 0
+        node.left = deleteAVLNode!(left(node), data, compare)
+    elseif result > 0
+        node.right = deleteAVLNode!(right(node), data, compare)
+    else
+        if !hasleft(node) || !hasright(node)
+            temp = treenil
+            if temp == left(node)
+                temp = right(node)
+            else
+                temp = left(node)
+            end
+
+            if temp === treenil
+                temp = node
+                node = treenil
+            else
+                node = temp
+            end
+        else
+            temp = minValueNode(right(node))
+            node.data = dataof(temp)
+            node.right = deleteAVLNode!(right(node), dataof(temp), compare)
+        end
+    end
+
+    if node === treenil
+        return node
+    end
+
+    node.height = max(height(left(node)), height(right(node))) + 1
+    return rebalance!(node)
+end
+
+function minValueNode(node::Union{AVLTreeNode, BinaryTreeNil})
+    current = node
+    while current !== treenil && left(current) !== treenil
+      current = left(current)
+    end
+  
+    return current
+end
+
+eltype(::BinaryTreeNode{T}) where T = T
+eltype(::AVLTreeNode{T}) where T = T

src/exceptioins.jl src/exceptions.jl

@@ -3,15 +3,14 @@ module LinkedList
 import Base: iterate, show, push!, pop!, popat!, pushfirst!, popfirst!,
     isempty, length,
     first, last,
-    replace!, filter, keys, eltype
+    replace!, filter, keys, eltype, convert
 
 export ForwardList, List, ForwardNode, ListNode, AbstractLinkedList, AbstractListNode, AbstractConsNode,
     iterate, show, push!, popat!, pushfirst!, popfirst!,
     isempty, length, first, last, replace!, filter, keys, eltype,
-    insertNext!, removeNext!, dataof
+    insertNext!, removeNext!, dataof, NilNode
 
 include("nodes.jl")
-include("exceptioins.jl")
 include("lists.jl")
 
 end # module LinkedList