Swift Equatable 泛型函数内的泛型类型比较

Question

我有一个Node二叉树类，如下所示：

class Node<T: Equatable> {
    let value: T
    let left: Node<T>?
    let right: Node<T>?

    init(value: T, left: Node<T>? = nil, right: Node<T>? = nil) {
        self.value = value
        self.left = left
        self.right = right
    }
}

这些值必须是相等的。

我可以这样测试公平性：

let a = Node(value: 8)
let b = Node(value: 7)

let c = a.value > b.value

效果很好，c: true

但是当我编写一个使用节点公平性的通用函数时，我收到错误：

func isBinaryTree<T>(node: Node<T>) -> Bool {
    if let leftNode = node.left {
        guard leftNode.value < node.value else {
            return false
        }
        guard isBinaryTree(node: leftNode) else {
            return false
        }
    }
    if let rightNode = node.right {
        guard rightNode.value >= node.value else {
            return false
        }
        guard isBinaryTree(node: rightNode) else {
            return false
        }
    }

    return true
}

let result = isBinaryTree(node: root)

错误：

error: binary operator '<' cannot be applied to two 'T' operands guard leftNode.value < node.value ||`

我不确定为什么编译器似乎不知道这些T值的原因Equatable，或者为什么它不认为 的T与的类型leftNode相同。Tnode

代码：

let d = Node(value: Float(3), left: Node(value: Int(8)) , right: nil)

给出了预期的错误。

进一步研究这一点，它与函数无关，因为当我尝试代码时：

let x = Node(value: 3, left: Node(value: 8) , right: nil)
let y = x.value < x.left!.value

我犯了同样的错误

Answer 1

一般情况下，两个Node对象不具有可比性。这取决于它们所在的树的类型。例如，如果节点仅被限制为二叉树的有效成员，那么这是有意义的，但事实并非如此。

Node幸运的是，你不需要Comparable，你只需要它value是Comparable：

class Node<T: Comparable> {
    let value: T
    let left: Node<T>?
    let right: Node<T>?

    init(value: T, left: Node<T>? = nil, right: Node<T>? = nil) {
        self.value = value
        self.left = left
        self.right = right
    }
}

extension Node: Equatable {
    static func == (lhs: Node, rhs: Node) -> Bool {
        return lhs.value == rhs.value
            && lhs.left == rhs.left
            && lhs.right == rhs.right
    }
}

extension Node {
    func isBinarySubTree() -> Bool {
        return left.map { $0.value < self.value } ?? true
            && right.map { self.value < $0.value } ?? true
            && left?.isBinaryTree() ?? true
            && right?.isBinaryTree() ?? true
    }
}