Question

尝试解决二叉树中点头的问题。树

具有以下继任者：8-> 10、10-> 12和14-> 20

但是，有10个我返回nil（实际上有14个我返回nil）。

我的算法是：

func inorderSucc(_ node: Node? = nil) -> Node? {
    if (node == nil) {
        return nil
    } else {
        if let rhn = node?.right {
            return leftMostChild(rhn)
        } else {
            var q = node
            var x = node?.parent
            while (x != nil && x!.left != q) {
                q = x
                x = x?.parent
            }
            return x
        }
    }
}

func leftMostChild(_ n: Node) -> Node? {
    var node = n
    while (node.left != nil) {
        node = node.left!
    }
    return node
}

叫树：

class Node : CustomStringConvertible, Hashable{
    var hashValue : Int { return data}
    static func == (lhs: Node, rhs: Node) -> Bool {
        return lhs.data == rhs.data
    }

    var data : Int
    var left : Node?
    var right : Node?
    var parent : Node? = nil
    var description: String {
        return String(data) + (left?.description ?? "") + (right?.description ?? "")
    }

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

    func insert(_ data: Int) {
        if (data < self.data){
            if let lhs = left {
                lhs.insert(data)
            }
            else {
                let lhNode = Node(data)
                lhNode.parent = self
                left = lhNode
            }
        }
        else {
            if let rhs = right {
                rhs.insert(data)
            }
            else {
                let rhNode = Node(data)
                rhNode.parent = self
                right = rhNode
            }
        }
    }
}

inorderSearch是：

func inorderSearch (_ node: Node, _ data: Int) -> Node? {
    if (node.data == data) {return node}
    else {
        if let lft = node.left {
            return inorderSearch(lft, data)
        }

        if let rht = node.right {
            return inorderSearch(rht, data)
        }

    }

    return nil
}

然后按如下所示插入节点：

let gfg = Node(20)
gfg.insert(8)
gfg.insert(4)
gfg.insert(12)
gfg.insert(10)
gfg.insert(14)
gfg.insert(22)
print (gfg)
inorderSucc(inorderSearch(gfg, 8))
inorderSucc(inorderSearch(gfg, 10))
inorderSucc(inorderSearch(gfg, 14))

最后三行分别返回10，nil和nil。怎么了？

Answer 1

此问题源于您的搜索功能。想一想如果没有在最左边的分支上找到实际的数字（根节点的左节点的子节点，左节点的子节点等等）时发生了什么情况。可能的更正方法是在探索左侧时检查nil，然后再进入子图的右侧。

func inorderSearch (_ node: Node, _ data: Int) -> Node? {
    if (node.data == data) {return node}
    else {
        if let lft = node.left, let found = inorderSearch(lft, data) {
            return found
        } else if let rht = node.right, let found = inorderSearch(rht, data) {
            return found
        } else {
            return nil
        }
    }
}

此代码假设您对这是哪种图形没有任何先入之见。否则，您还可以检查搜索到的数字是否大于或小于当前节点的值，并在左侧或右侧进行相应的搜索。

Answer 2

您可以这样做：

首先，像这样声明Node类：

class Node {
    let value: Int
    var leftChield: Node?
    var rightChield: Node?

    init(value: Int, leftChield: Node?, rightChield: Node?) {
        self.value = value
        self.leftChield = leftChield
        self.rightChield = rightChield
    }    
}

然后创建所有分支：

    //Left Branch
    let tenNode = Node(value: 10, leftChield: nil, rightChield: nil)
    let fourteenNode = Node(value: 14, leftChield: nil, rightChield: nil)
    let twelveNode = Node(value: 12, leftChield: tenNode, rightChield: fourteenNode)
    let foureNode = Node(value: 4, leftChield: nil, rightChield: nil)
    let eithNode = Node(value: 8, leftChield: foureNode, rightChield: twelveNode)

    //Right Branch
    let twentytwoNode = Node(value: 22, leftChield: nil, rightChield: nil)

    // Root Node
    let rootTwentyNode = Node(value: 20, leftChield: eithNode, rightChield: twentytwoNode)

然后使用逻辑创建一个函数：

        func binarySearch(node: Node?, searchValue: Int) -> Bool {

            if node == nil {
                return false
            }

            if node?.value == searchValue {
                return true
            } else if searchValue < node!.value {
                return binarySearch(node: node?.leftChield, searchValue: searchValue)
            } else {
                return binarySearch(node: node?.rightChield, searchValue: searchValue)
            }
        }

最后，像这样调用该函数，并为rootNode添加所需的值。

binarySearch(node: rootNode, searchValue: 50)

二进制搜索树中节点的后继者-Swift

2 个答案: