算法学习之路（三）

1、验证搜索二叉树

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

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

示例 1：
输入：root = [2,1,3]
输出：true
示例 2：
输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

 

# 解法一 利用递归中序遍历
    def isValidBST(self, root: TreeNode) -> bool:
        self.prev = None
        return self.helper(root)
    def helper(self,root) -> object:
        if root is None:
            return True
        if not self.helper(root.left):
            return False
        if self.prev and self.prev.val >= root.val:
            return False
        self.prev = root
        return self.helper(root.right)


# 解法二
"""
    class Solution:

    def isValidBST(self, root: TreeNode) -> bool:
        inorder = self.inorder(root)  # 将inorder的函数返回值赋值给 inorder
        return inorder == list(sorted(set(inorder)))  # 对于赋值给的 inorder 进行比较返回 TRUE 和 FALSE

    def inorder(self, root):
       
        if not root:
            return []
        return self.isValidBST(root.left) + [root.val] + self.inorder(root.right)
"""

2、二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
示例 2：

输入：root = [1]
输出：[[1]]
示例 3：

输入：root = []
输出：[]

import collections
# 解法一 双队列
class Solution:
    def levelOrder(self, root: TreeNode) -> list[list[int]]:
        if not root:
            return []
        res = []
        queue = collections.deque()  # 用到了队列，这边也是初始化一个双边队列，
        queue.append(root)  # 把树的根节点放入队列中
        while queue:
            m = len(queue)  # 记录当前层的队列中的数目，目的是因为题目需要记录每层的长度
            ans = []  # 因为要求逐层输出，所以还需要一个中间过渡参数
            for i in range(m):
                tmp = queue.popleft()  # 首先将队列中的第一个点弹出来
                ans.append(tmp.val)  # 将第一个点的值放入过渡参数中
                if tmp.left:  # 因为上一步已经将当前节点的值放入过渡参数中，
                    # 下一步就是要将其的左右子树再放入队列中。此时，需要对弹出节点进行判断，如果有左节点，
                    # 则将左节点放入队列中。
                    queue.append(tmp.left)
                if tmp.right:
                    queue.append(tmp.right)
            res.append(ans)
        return res

#解法二 BFS & DFS
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        queue = collections.deque()
        queue.append(root)
        res = []
        while queue:
            size = len(queue)
            level = []
            for _ in range(size):
                cur = queue.popleft()
                if not cur:
                    continue
                level.append(cur.val)
                queue.append(cur.left)
                queue.append(cur.right)
            if level:
                res.append(level)
        return res

3、 在排序数组中查找元素的第一个和最后一个位置

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

进阶：

你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]
示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]
示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

class Solution:
    def search(self, nums: list[int], target: int) -> int:
        if len(nums) < 2 :
            if target in nums:
                return 0
            else:
                return -1
        else:
            low = 0
            high = len(nums) -1
            mid = low + (high - low) //2
            while low <= high:
                if nums[mid] == target:
                    return mid
                if nums[low] < nums[mid]:
                    if nums[low] <= target < nums[mid]:
                        high = mid - 1
                    else:
                        low = mid + 1
                else:
                    if nums[mid] <= target < nums[high]:
                        low = mid + 1
                    else:
                        high = mid - 1
        return -1

4、搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2
示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1
示例 3:

输入: nums = [1,3,5,6], target = 7
输出: 4
示例 4:

输入: nums = [1,3,5,6], target = 0
输出: 0
示例 5:

输入: nums = [1], target = 0
输出: 0

class Solution:
    def searchInsert(self, nums: list[int], target: int) -> int:
        if nums[0] == 0 and len(nums) == 1 :
            return 0
        if target in nums:
            for i in range(len(nums)):
                if nums[i] == target:
                    return i
        else:
            if target == 0 and len(nums) == 1:
                 return 0
            elif nums[-1] > target:
                for j in range(len(nums)):
                    if target < nums[j]:
                        return j
            elif nums[-1] < target:
                return len(nums)

5、搜索二维矩阵

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：

每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。

示例 1：

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
输出：true
示例 2：

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
输出：false

class Solution:
    def searchMatrix(self, matrix: list[list[int]], target: int) -> bool:
        if not matrix and not matrix[0]:
            return False
        else:
            rows = len(matrix)
            cols = len(matrix[0])
            row = 0
            col = cols -1
            while True:
                if row < rows and col >= 0:
                    if matrix[row][col] == target:
                        return True
                    elif matrix[row][col] < target:
                        row += 1
                    else:
                        col -= 1
                else:
                    return False

 6、寻找旋转数组中的最小值

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]
注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。
示例 2：

输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。
示例 3：

输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

# 方法一：暴力解法
class Solution:
    def findMin(self, nums: list[int]) -> int:
        min_num = float('inf')
        for i in range(len(nums)):
            if min_num > nums[i]:
                min_num = nums[i]
        return min_num

# 方法二：二分查找
"""
class Solution:
    def findMin(self, nums: List[int]) -> int:    
        low, high = 0, len(nums) - 1
        while low < high:
            pivot = low + (high - low) // 2
            if nums[pivot] < nums[high]:
                high = pivot 
            else:
                low = pivot + 1
        return nums[low]
"""