树理论与二叉树习题:验证二叉树、二叉树(二叉搜索树)最近公共祖先

树,二叉树,二叉搜索树

链表:每个next指向后续节点

当要访问中间的节点时,要从头或双向链表从尾部去找。

所以当一个节点有多个next,比如left与right,child1、child2…就形成了树。树是无环单向链接的。

二叉树:一个节点最多只有两个子节点。

在这里插入图片描述
在这里插入图片描述

如果孩子节点再指向回去,则是图。

Python:实现二叉树

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

二叉树的遍历:

  • 前序:根左右
  • 中序:左根右
  • 后序:左右根

(btw:在实际的使用中用的很少,常用的都是深度优先遍历与广度优先遍历)

    #前序遍历代码,另外两种同理。
    def preorder(self,root):
        if root:
            #访问根节点
            self.traverse_path.append(root.val)
            self.preorder(root.left)
            self.preorder(root.right)

二叉搜索树(有序二叉树)

是指一棵空树,或者具有以下性质的树:

  1. 左子树上所有的节点的值均小于它的根节点的值。
  2. 右子树上所有的节点的值均大于它的根节点的值
  3. 递归的,左、右子树也分别为二叉搜索树

二叉搜索树如果只有一边的子树,则查询的时间是最差O(n),平均为O(log(n))。如果出现最差可以使用二叉平衡树来重新建树。

98.验证二叉搜索树

来源链接:https://leetcode-cn.com/problems/validate-binary-search-tree

给定一个二叉树,判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征:

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

示例:

输入:
    2
   / \
  1   3
输出: true

输入:
    5
   / \
  1   4
     / \
    3   6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
     根节点的值为 5 ,但是其右子节点值为 4 。

思路1:根据二叉搜索树的特点可知,二叉搜索树的中序遍历是升序的,且没有重复的值。所以可以写出树中序遍历的结果,查看他是否是无重复且升序排列的。时间复杂度O(n)

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        global res
        res =[]
        self.inOrder(root)
        #要去重,因为二叉搜索树是不可能有重复节点的
        #不去重的话,[1,1]树结果是错误的
        return res == sorted(set(res))

    def inOrder(self,node):
        if node:
            self.inOrder(node.left)
            res.append(node.val)
            self.inOrder(node.right)

优化思路:

不用存储所有的遍历结果,只用记录前驱节点。即当前驱节点比当前节点小就更新前驱节点继续遍历直到结束,否则返回false。

思路2:递归实现

根据搜索二叉树的性质,左子树上的节点值都不会大于根节点,右子树上的值都不会小根节点的值。

class Solution(object):
    def isValidBST(self,root):
        #float('-inf')一个很小的值
        def helper(root,min=float('-inf'),max=float('inf')):
            if not root:
                return True
            if root.val <= min or root.val >= max:
                return False
            if not helper(root.left,min,root.val):
                return False
            if not helper(root.right,root.val,max):
                return False
            return True
        
        return helper(root)

235.二叉搜索树的最近公共祖先

链接:https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree

题目:

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为:“对于有根树 T 的两个结点 p、q,最近公共祖先表示为一个结点 x,满足 x 是 p、q 的祖先且 x 的深度尽可能大(一个节点也可以是它自己的祖先)。”

例如,给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

img

示例1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6 
解释: 节点 2 和节点 8 的最近公共祖先是 6。

思路:

根据二叉搜索树的性质,可以将p与q与根节点的值v比较:

  • p<v<q:表示p,q分别在根的两边,所以最近的公共祖先就是v
  • p<q<v:p,q在v的左子树,继续将v.left与p,q比较
  • v<p<q:p,q在v的右子树,继续将v.right与p,q比较

这里应该是要使用递归的。

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """

        if root.val>max(p.val,q.val) :
            return self.lowestCommonAncestor(root.left,p,q)
        if root.val<min(p.val,q.val):
            return self.lowestCommonAncestor(root.right,p,q)
        else:
            return root

非递归的方式:

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        while root:
            if root.val<min(p.val,q.val):
                root = root.right
            elif root.val>max(p.val,q.val):
                root = root.left
            else:
                return root

236.二叉树的最近公共祖先(中等)

链接:https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为:“对于有根树 T 的两个结点 p、q,最近公共祖先表示为一个结点 x,满足 x 是 p、q 的祖先且 x 的深度尽可能大(一个节点也可以是它自己的祖先)。”

例如,给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]

img

思路1:普通二叉树没有搜索二叉树的性质。所以上一个方法不能直接使用。所以可以使用路径寻找法。利用父亲指针,但此题没有父亲节点,不适用。只能从根节点遍历到p/q,路径就代表p/q的父节点们。然后找最后一个公共节点。比较麻烦,不附代码。

思路2:利用辅助函数_findPorQ(root,p,q)递归

  • 从根节点开始寻找,如果根是None,p,q中一个则返回根节点即为公共节点。
  • 同时将root.left与root.right作为根节点在左右两个子树中寻找left与right。
  • 最后判断left与right:一般三种情况left与right都找到了则返回root即可。只找到left则返回left,否则返回None,只找到right则返回right,否则返回None。
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        #root == None 是在找不到的时候返回空即可
        if root == None or root == p or root == q:
            return root
        left = self.lowestCommonAncestor(root.left,p,q)
        right = self.lowestCommonAncestor(root.right,p,q)
        
		#这个判断需要好好理一下
        if left != None:
            if right != None:
                return root
            return left
        elif right != None:
            return right
        return None

tips:**二叉树的主要考点——递归。**不但要可以口头表达思想,还要能够用代码实现。实现之后才是真的理解。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值