Swift 快速二叉搜索树搜索

我正在尝试实现一个存储单词列表的BST。我知道我的树结构是正确的，因为当我尝试按顺序遍历和打印时，列表按字母顺序打印。但是，我在树中查找元素的搜索函数每次都返回false

func search(searchValue: String) -> Bool? {
    if searchValue == value as! String{
        return true
    }

    if searchValue < value as! String {
        return left?.search(searchValue: searchValue)
    }
    if searchValue > value as! String{
        return right?.search(searchValue: searchValue)
    }

    return false


}

有关上下文的更多BST类：

  public class BinarySearchTree<T: Comparable> {
        fileprivate(set) public var value: T
        fileprivate(set) public var parent: BinarySearchTree?
        fileprivate(set) public var left: BinarySearchTree?
        fileprivate(set) public var right: BinarySearchTree?


        public init(value: T) {
            self.value = value
        }

        public convenience init(array: [T]) {
            precondition(array.count > 0)
            self.init(value: array.first!)
            for v in array.dropFirst() {
                insert(value: v)
            }
        }

        }
     public func insert(value: T) {
            if value < self.value {
                if let left = left {
                    left.insert(value: value)
                } else {
                    left = BinarySearchTree(value: value)
                    left?.parent = self
                }
            } else {
                if let right = right {
                    right.insert(value: value)
                } else {
                    right = BinarySearchTree(value: value)
                    right?.parent = self
                }
            }
        }

公共类二进制搜索树{
fileprivate（set）公共变量值：T
fileprivate（set）公共变量父级：BinarySearchTree？
fileprivate（set）public var left:BinarySearchTree？
fileprivate（set）公共变量权限：BinarySearchTree？
公共初始化（值：T）{
自我价值=价值
}
公共便利初始化（数组：[T]）{
前提条件（array.count>0）
self.init（值：array.first！）
对于数组中的v.dropFirst（）{
插入（值：v）
}
}
}
公共函数插入（值：T）{
如果值

我认为问题在于，您正在到达二进制搜索树的叶节点，然后返回nil。拼写错误的单词小于或大于叶的存储值，因此您正在查找左或右子项，这些值为nil，因此函数返回nil

有几种方法可以解决这个问题，但最简单的更改是当左或右为零时，将nil合并为false

func search(searchValue: String) -> Bool {
    if searchValue == value as! String {
        return true
    }

    if searchValue < value as! String {
        return left?.search(searchValue: searchValue) ?? false
    }
    if searchValue > value as! String {
        return right?.search(searchValue: searchValue) ?? false
    }

    return false
}

func搜索（searchValue:String）->Bool{
如果searchValue==值为！字符串{
返回真值
}
如果searchValue<值为！字符串{
返回左？搜索（searchValue:searchValue）？假
}
如果搜索值>值为！字符串{
返回权限？搜索（searchValue:searchValue）？错误
}
返回错误
}

我认为问题在于，您正在到达二进制搜索树的叶节点，然后返回nil。拼写错误的单词小于或大于叶的存储值，因此您正在查找左或右子项，这些值为nil，因此函数返回nil

有几种方法可以解决这个问题，但最简单的更改是当左或右为零时，将nil合并为false

func search(searchValue: String) -> Bool {
    if searchValue == value as! String {
        return true
    }

    if searchValue < value as! String {
        return left?.search(searchValue: searchValue) ?? false
    }
    if searchValue > value as! String {
        return right?.search(searchValue: searchValue) ?? false
    }

    return false
}

func搜索（searchValue:String）->Bool{
如果searchValue==值为！字符串{
返回真值
}
如果searchValue<值为！字符串{
返回左？搜索（searchValue:searchValue）？假
}
如果搜索值>值为！字符串{
返回权限？搜索（searchValue:searchValue）？错误
}
返回错误
}

我对您的代码做了一些改进，请看：

public class BinarySearchTree<T: Comparable> {
    fileprivate(set) public var value: T
    fileprivate(set) public var parent: BinarySearchTree?
    fileprivate(set) public var left: BinarySearchTree?
    fileprivate(set) public var right: BinarySearchTree?


    public init(value: T) {
        self.value = value
    }

    public convenience init(array: [T]) {
        precondition(array.count > 0)
        self.init(value: array.first!)
        for v in array.dropFirst() {
            insert(value: v)
        }
    }

    // Refactored out common code to reduce duplicaiton
    public func insert(value: T) {
        let nodeToModify = value < self.value ? left : right

        if let nodeToModify = nodeToModify {
            nodeToModify.insert(value: value)
        }
        else {
            let subtree = BinarySearchTree(value: value)
            subtree.parent = self
            self.left = subtree
        }
    }


    // Why constrain searching to just Strings? Keep it generic to all T: Comparable
    func search(for searchValue: T) -> Bool {
        if searchValue == value { return true }

        if searchValue < value {
            return left?.search(for: searchValue) ?? false
        }
        if searchValue > value {
            return right?.search(for: searchValue) ?? false
        }

        return false
    }
}

// Move the `search` function outside of the class, and into an extension
// with the constaint that `T == String`
extension BinarySearchTree where T == String {
    func search(for searchValue: String) -> Bool {
        if searchValue == value { return true }

        if searchValue < value {
            return left?.search(for: searchValue) ?? false
        }
        if searchValue > value {
            return right?.search(for: searchValue) ?? false
        }

        return false
    }
}

公共类二进制搜索树{
fileprivate（set）公共变量值：T
fileprivate（set）公共变量父级：BinarySearchTree？
fileprivate（set）public var left:BinarySearchTree？
fileprivate（set）公共变量权限：BinarySearchTree？
公共初始化（值：T）{
自我价值=价值
}
公共便利初始化（数组：[T]）{
前提条件（array.count>0）
self.init（值：array.first！）
对于数组中的v.dropFirst（）{
插入（值：v）
}
}
//重构公共代码以减少重复
公共函数插入（值：T）{
让nodeToModify=valueBool{
如果searchValue==值{return true}
如果searchValue值{
返回权限？搜索（搜索：searchValue）？错误
}
返回错误
}
}
//将'search'函数移到类之外，并移到扩展中
//使用`T==String的常量`
扩展二进制搜索树，其中T==String{
func search（对于searchValue:String）->Bool{
如果searchValue==值{return true}
如果searchValue值{
返回权限？搜索（搜索：searchValue）？错误
}
返回错误
}
}

我对您的代码做了一些改进，请看：

public class BinarySearchTree<T: Comparable> {
    fileprivate(set) public var value: T
    fileprivate(set) public var parent: BinarySearchTree?
    fileprivate(set) public var left: BinarySearchTree?
    fileprivate(set) public var right: BinarySearchTree?


    public init(value: T) {
        self.value = value
    }

    public convenience init(array: [T]) {
        precondition(array.count > 0)
        self.init(value: array.first!)
        for v in array.dropFirst() {
            insert(value: v)
        }
    }

    // Refactored out common code to reduce duplicaiton
    public func insert(value: T) {
        let nodeToModify = value < self.value ? left : right

        if let nodeToModify = nodeToModify {
            nodeToModify.insert(value: value)
        }
        else {
            let subtree = BinarySearchTree(value: value)
            subtree.parent = self
            self.left = subtree
        }
    }


    // Why constrain searching to just Strings? Keep it generic to all T: Comparable
    func search(for searchValue: T) -> Bool {
        if searchValue == value { return true }

        if searchValue < value {
            return left?.search(for: searchValue) ?? false
        }
        if searchValue > value {
            return right?.search(for: searchValue) ?? false
        }

        return false
    }
}

// Move the `search` function outside of the class, and into an extension
// with the constaint that `T == String`
extension BinarySearchTree where T == String {
    func search(for searchValue: String) -> Bool {
        if searchValue == value { return true }

        if searchValue < value {
            return left?.search(for: searchValue) ?? false
        }
        if searchValue > value {
            return right?.search(for: searchValue) ?? false
        }

        return false
    }
}

公共类二进制搜索树{
fileprivate（set）公共变量值：T
fileprivate（set）公共变量父级：BinarySearchTree？
fileprivate（set）public var left:BinarySearchTree？
fileprivate（set）公共变量权限：BinarySearchTree？
公共初始化（值：T）{
自我价值=价值
}
公共便利初始化（数组：[T]）{
前提条件（array.count>0）
self.init（值：array.first！）
对于数组中的v.dropFirst（）{
插入（值：v）
}
}
//重构公共代码以减少重复
公共函数插入（值：T）{
让nodeToModify=value