Swift中的DFS未终止

我对BFS的实施效果良好：

func bfsReturnVals() -> [Int] {
    // bfs uses a queue.
    var queue = [Node]()
    var queueVals = [Int]()
    queue.append(self)
    while let head = queue.first {
        if let lft = head.left {
            queue.append(lft)
        }
        if let rgt = head.right {
            queue.append(rgt)
        }
        queueVals.append(queue[0].data)
        queue.removeFirst()
    }

    return queueVals
}

但我通常递归地编写DFS。现在，DFS的类似实现并未终止

func dfsReturnVals() -> [Int] {
    var stack = [Node]()
    var queueVals = [Int]()
    stack.append(self)
    while let tail = stack.last {
        if let lft = tail.left {
            stack.append(lft)
        }
        if let rgt = tail.right {
            stack.append(rgt)
        }
        queueVals.append(stack[stack.count - 1].data)
        stack.removeLast()
    }
    return queueVals
}

我不明白为什么。removeLast（）不应该像removeFirst（）那样工作吗

我的节点类如下所示：

class Node : CustomStringConvertible {
    var description : String {return "\(self.data)" }
    var data : Int
    var left: Node?
    var right: Node?

    init(_ data: Int) {
        self.data = data
    }

    func insert(_ data: Int) {
        if data < self.data {
            if let lft = self.left {
                lft.insert(data)
            } else {
                let newNode = Node(data)
                left = newNode
            }
        } else {
            if let rgt = self.right {
                rgt.insert(data)
            } else {
                let newNode = Node(data)
                right = newNode
            }
        }
    }
}

类节点：CustomStringConvertible{
变量说明：字符串{return“\（self.data）”}
变量数据：Int
左：节点？
右：节点？
初始化（数据：Int）{
self.data=数据
}
函数插入（u数据：Int）{
如果数据

当您从堆栈中删除最后一个项目时，您正在删除刚才推送的项目。在bfs实现中，remove first将捕获预期的父节点，而不管您是在循环结束时执行此操作的，因为您将子节点添加到队列的末尾。在推送新节点之前，您应该将从堆栈中删除扩展节点的操作移动到。

您是否尝试使用Swift调试器来查找逻辑错误？您在回答之前的问题时没有得到DFS实现吗？“你试过那个吗？”马丁纳，是的，我试过了，效果很好。但是，我提出了自己的实现（不仅仅是复制和粘贴）供个人研究，并且遇到了如上所述的问题。