劍指offer(8)-------------二叉樹中序遍歷的下一個節點

使用兩種方法實現。

方法一：中序遍歷二叉樹，記錄指定節點，當遍歷到下一個節點時返回

時間複雜度o(n)

 

方法二:

1）當指定節點有右子樹時，返回其右子樹的第一個中序遍歷節點

2）當指定節點無右子樹時，如果其是父節點的左節點，則返回其父節點

3）當指定節點無右子樹，且是其父節點的右節點，則一直向上找父節點，當找到某個父節點是其父節點的左節點時返回

時間複雜度o(logn)

 

代碼實現:

class BinNode:
    def __init__(self, val, left=None, right=None, father=None):
        self.val = val
        self.left = left
        self.right = right

        if self.left:
            self.left.father = self
        if self.right:
            self.right.father = self

        self.father = father

    def __str__(self):
        return self.val

def no_traverse_next(target):
    if target.right:
        r = target.right
        while r.left:
            r = r.left
        return r

    f = target
    ff = f.father
    while f and ff:
        if ff.left == f:
            return ff
        else:
            f = ff
            ff = ff.father
    return None


def inorder_traverse_next(root, target):
    prev, node, stack = None, root, []
    while node or stack:
        if node:
            stack.append(node)
            node = node.left
        else:
            n = stack.pop()
            if n == target:
                prev = n
            if prev and n != target:
                return n
            node = n.right
    return None

if __name__ == "__main__":
    i = BinNode('i')
    h = BinNode('h')
    g = BinNode('g')
    f = BinNode('f')
    e = BinNode('e', h, i)
    d = BinNode('d')
    c = BinNode('c', f, g)
    b = BinNode('b', d, e)
    a = BinNode('a', b, c)

    print(inorder_traverse_next(a, i))
    print(inorder_traverse_next(a, b))
    print(inorder_traverse_next(a, g))

    print(no_traverse_next(i))
    print(no_traverse_next(b))
    print(no_traverse_next(g)