Swift 如何解决这个二叉树反序列化问题？

这个序列化函数中的错误在哪里

我在Swift中编写了一个反序列化函数，用于从可选整数数组构造二叉树。我通过将输出与使用相同数组的手动方法构建的树的输出进行比较来测试此函数。他们看起来一样，这很好

然而，当我运行另一个函数isSameTree时，它用于比较两个树，我确信这个函数工作正常，在反序列化的输出和手动方法的输出上，我得到了不同的结果

我假设反序列化是不正确的，但我找不到错误

//助手代码

public class BinaryNode {
     public var value: Int
     public var left: BinaryNode?
     public var right: BinaryNode?
     public init(_ value: Int) {
         self.value = value
         self.left = nil
         self.right = nil
     }
 }

extension BinaryNode {
    public var description: String {
        return diagram(for: self)
    }
    private func diagram(for node: BinaryNode?,
                         _ top: String = "",
                         _ root: String = "",
                         _ bottom: String = "") -> String {
        guard let node = node else {
            return root + "nil\n"
        }
        if node.left == nil && node.right == nil {
            return root + "\(node.value)\n"
        }
        return diagram(for: node.right,
                       top + " ", top + "┌──", top + "│ ")
            + root + "\(node.value)\n"
            + diagram(for: node.left,
                      bottom + "│ ", bottom + "└──", bottom + " ")
    }
}

public func deserialize(_ array: inout [Int?]) -> BinaryNode? {
    guard !array.isEmpty, let value = array.removeFirst() else {
        return nil
    }
    let node = BinaryNode(value)
    node.left = deserialize(&array)
    node.right = deserialize(&array)
    return node
}

func isSameTree(_ p: BinaryNode?, _ q: BinaryNode?) -> Bool {
        guard let p = p else {
            return q == nil
        }
        guard let q = q else {
            return p == nil
        }

        if p.value != q.value {
            return false
        }

        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right)
    }


// Using deserialize to construct trees
var a1: [Int?] = [1,nil,2,3]
var a2: [Int?] = [1,nil,2,nil,3]
if let tree = deserialize(&a1) {
    print(tree.description)
}

if let tree = deserialize(&a2) {
    print(tree.description)
}

// Using manual to construct trees
let a3: BinaryNode = {
    let one = BinaryNode(1)
    let two = BinaryNode(2)
    let three = BinaryNode(3)
    one.right = two
    two.left = three
    return one
}()
print(a3.description)
let a4: BinaryNode = {
    let one = BinaryNode(1)
    let two = BinaryNode(2)
    let three = BinaryNode(3)
    one.right = two
    two.right = three
    return one
}()
print(a4.description)

// The print statements above show similar trees are constructed
// However, below results are not same

isSameTree(deserialize(&a1), deserialize(&a2)) // true <- this is wrong
isSameTree(a3, a4) // false <--- this is correct

---

似乎您忘记了反序列化：对其参数具有破坏性。。。请记住你为什么需要&

//Re-load a1 & a2...
a1 = [1,nil,2,3]
a2 = [1,nil,2,nil,3]
print(isSameTree(deserialize(&a1), deserialize(&a2))) //-> false
print(isSameTree(a3, a4)) //-> false