找到二叉树中符合搜索二叉树条件的最大拓扑结构

最新推荐文章于 2024-03-30 23:07:08 发布

BUPT-WT

最新推荐文章于 2024-03-30 23:07:08 发布

阅读量257

点赞数

CC 4.0 BY-SA版权

分类专栏：秋招

本文链接：https://blog.youkuaiyun.com/weixin_41362649/article/details/97885918

秋招专栏收录该内容

179 篇文章

订阅专栏

本文介绍了一种寻找给定二叉树中最大的且符合搜索二叉树条件的拓扑结构的方法，提供了两种算法，一种时间复杂度为O(N^2)，另一种优化后的时间复杂度为O(N)，并详细解释了这两种算法的具体实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：

给定一个头节点head，已知所有节点的值都不一样，返回其中最大的且符合搜索二叉树条件的最大拓扑结构的大小

方法一：二叉树节点数为N,时间复杂度为O(N^2)的方法

class Node:
    def __init__(self,value):
        self.value = value
        self.left = None
        self.right = None

    
def getTopSize1(head):

    if head == None:
       return 0

    max_ = max(getTopSize1(head.left),maxTopo(head,head))
    max_ = max(getTopSize1(head.right),maxTopo(head,head))

    return max_


def maxTopo(head,node):

    if head!=None and node!=None and isBSTnode(head,node,node.value):
        rerturn maxTopo(head,node.left) + maxTopo(head,node.right) + 1

def isBSTnode(head,node,value):

    if head == None:
        return False

    if head == node:
        return True

    if head.value > value:
        return isBSTnode(head.left,node,value)
    else:
        return isBSTnode(head.right,node,value)

方法2 二叉树的节点数为N，时间复杂度为O(N)的方法

class Record:
    
    def __init__(self,left,right):
        self.l = left
        self.r = right
        
def bstTopoSize2(head):
    map_ = {}
    
    return posOrder(head,map_)

def posOrder(head,map_):
    
    if head == None:
        return 0
    
    ls = preOrder(head.left,map_)
    rs = preOrder(head.right,map_)
    modifyMap(head.left,head.value,map_,True)
    modifyMap(head.right,head.value,map_,False)
    
    lr = map_[head.left]
    rr = map_[head.right]
    
    if lr == None:
        lbst = 0
    else:
        lbst = lr.l + lr.r + 1
        
    if rr == None:
        rbst = 0
    else:
        rbst = rr.l + rr.r + 1
        
    map_[head] = Record(lbst,rbst)
    
    return max(lbst+rbst+1,max(ls,rs))

def modifyMap(node,value,map_,s):
    
    if node == None or node not in map_:
        return 0
    
    r = map_[node]
    
    if (s and node.value > v) or (s is False and node.value < value):
        map_.pop(node)
        return r.l + r.r+1
    else:
        if s:
            minus = modifyMap(node.right,value,map_,s)
        else:
            minus = modifyMap(node.left,value,map_,s)
            
        if s:
            r.r = r.r - minus
        else:
            r.l = r.l - minus
            
        m[n] = r
        
    return minus