Swift 快速广度优先搜索

我对二叉树的BFS有点疯狂

它返回正确的元素，但似乎我多次将同一个节点插入队列

出什么事了？算法应该不会这么难，但我似乎已经做到了

func breadthFirstSearch(_ data: Int) -> Node? {
    var queue = [Node]()
    if (self.data == data) { return self }
    queue.append(self)
    var tempNode = queue[0]

    while queue.count > 0 {
        if (tempNode.data == data) { return tempNode }

        if let lft = tempNode.left {
            queue.append(lft)
        }
        if let rht = tempNode.right {
            queue.append(rht)
        }
        tempNode = queue[0]
        queue.remove(at: 0)

    }
    return nil
}

树在哪里

class Node: CustomStringConvertible {
    var data : Int
    var left: Node?
    var right: Node?

    init(_ data : Int) {
        self.data = data
    }
    var description: String {
        return String(data) + ((left != nil) ? left!.description : "") + ((right != nil) ? right!.description : "")
    }

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

和插入

var binaryTree = Node(10)
binaryTree.insert(5)
binaryTree.insert(20)
binaryTree.insert(3)
binaryTree.insert(15)
binaryTree.breadthFirstSearch(4)

---

您只需删除

tempNode

变量，并始终使用队列头即可：

func breadthFirstSearch(_ data: Int) -> Node? {
    var queue = [self]

    while let head = queue.first {
        queue.remove(at: 0)

        if (head.data == data) {
          return head
        }

        if let lft = head.left {
            queue.append(lft)
        }

        if let rht = head.right {
            queue.append(rht)
        }
    }
    return nil
}

您最初的实现实际上会在第一个（根）节点上迭代两次。我还取消了一开始不必要的重复检查

现在，您还可以看到与深度优先搜索的区别：

func depthFirstSearch(_ data: Int) -> Node? {
    var stack = [self]

    while let head = stack.popLast() {
        if (head.data == data) {
            return head
        }

        if let lft = head.left {
            stack.append(lft)
        }

        if let rht = head.right {
            stack.append(rht)
        }
    }
    return nil
}

---

您只需删除

tempNode

变量，并始终使用队列头即可：

func breadthFirstSearch(_ data: Int) -> Node? {
    var queue = [self]

    while let head = queue.first {
        queue.remove(at: 0)

        if (head.data == data) {
          return head
        }

        if let lft = head.left {
            queue.append(lft)
        }

        if let rht = head.right {
            queue.append(rht)
        }
    }
    return nil
}

您最初的实现实际上会在第一个（根）节点上迭代两次。我还取消了一开始不必要的重复检查

现在，您还可以看到与深度优先搜索的区别：

func depthFirstSearch(_ data: Int) -> Node? {
    var stack = [self]

    while let head = stack.popLast() {
        if (head.data == data) {
            return head
        }

        if let lft = head.left {
            stack.append(lft)
        }

        if let rht = head.right {
            stack.append(rht)
        }
    }
    return nil
}

---

你期待什么结果？在您问题中的示例中，数字

4

从未插入到树中，因此对它的任何搜索都将返回

nil

。请提供一个示例来说明问题，在这种情况下您希望得到什么输出/结果，以及您实际得到什么输出/结果。您的

tempNode

是不必要的，这会使您的算法失败。请将while循环中的最后两行移到while循环的顶部。您希望得到什么结果？在您问题中的示例中，数字

4

从未插入到树中，因此对它的任何搜索都将返回

nil

。请提供一个示例来说明问题、在这种情况下您希望得到的输出/结果以及您实际得到的输出/结果。您的

tempNode

是不必要的，这会使您的算法失败。请将while循环中的最后两行移到while循环的顶部。