算法初级--树+排序和搜索+动态规划

Posted 2021-04-18 每日学习不落下

今天更新三个部分的初级算法的题目

树--二叉树

题目：二叉树的最大深度

内容： 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。    ‍

程序： # Definition for a binary tree node. # class TreeNode: #     def __init__(self, x): #         self.val = x #         self.left = None #         self.right = None class Solution:     def maxDepth(self, root: TreeNode) -> int:         if not root:             return 0         queue = [root]         res = 0         while queue:             tem = []             res += 1             for cur in queue:                                  if cur.left:                     tem.append(cur.left)                 if cur.right:                     tem.append(cur.right)             queue = tem         return res

题目：对称二叉树

内容： 给定一个二叉树，检查它是否是镜像对称的。    ‍

程序： # Definition for a binary tree node. # class TreeNode: #     def __init__(self, x): #         self.val = x #         self.left = None #         self.right = None class Solution:     def isSymmetric(self, root: TreeNode) -> bool:         def func(r1,r2):             if not r1 and not r2:                 return True             elif not r1:                 return False             elif not r2:                 return False             elif r1.val != r2.val:                 return False             else:                 return func(r1.left,r2.right) and func(r1.right,r2.left)         return func(root,root)

题目：二叉树的层序遍历

内容： 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。（即逐层地，从左到右访问所有节点）。    ‍

程序： # Definition for a binary tree node. # class TreeNode: #     def __init__(self, x): #         self.val = x #         self.left = None #         self.right = None class Solution:     def levelOrder(self, root: TreeNode) -> List[List[int]]:         if not root:             return []         queue = [root]         res = []         while queue:             tem = []             r = []             for cur in queue:                 r.append(cur.val)                 if cur.left:                     tem.append(cur.left)                 if cur.right:                     tem.append(cur.right)             res.append(r)             queue = tem         return res

题目：将有序数组转换为二搜索树

内容： 将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。 本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。    ‍

程序： # Definition for a binary tree node. # class TreeNode: #     def __init__(self, x): #         self.val = x #         self.left = None #         self.right = None class Solution:     def sortedArrayToBST(self, nums: List[int]) -> TreeNode:         def func(nums,root):             if not nums:                 return             mid = len(nums) // 2             root = TreeNode(nums[mid])             root.left = func(nums[:mid],root.left)             root.right = func(nums[mid+1:],root.right)             return root         return func(nums, TreeNode())

排序和搜索

题目：合并两个有序数组    ‍

内容： 给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。

程序： class Solution:     def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:         """         Do not return anything, modify nums1 in-place instead.         """         for i in range(m,m+n):             nums1[i] = nums2[i-m]         nums1[:m+n] = sorted(nums1[:m+n])

题目：第一个错误的版本

内容： 你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。 假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。 你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。    ‍

程序： # The isBadVersion API is already defined for you. # @param version, an integer # @return a bool # def isBadVersion(version): class Solution:     def firstBadVersion(self, n):         """         :type n: int         :rtype: int         """         left = 0         right = n         mid = (left + right) // 2         while left < right:                          mid = (left + right) // 2             if isBadVersion(mid):                 right = mid             else:                 left = mid+1         return right

动态规划

题目：爬楼梯

内容： 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？ 注意：给定 n 是一个正整数。

程序： class Solution:     def climbStairs(self, n: int) -> int:         if n == 1:             return 1         dp = [0] * n         dp[0] = 1         dp[1] = 2         for i in range(2,n):             dp[i] = dp[i-1] + dp[i-2]         return dp[-1]

  

题目：买卖股票的最佳时机

内容： 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。 注意：你不能在买入股票前卖出股票。    ‍

程序： class Solution:     def maxProfit(self, prices: List[int]) -> int:         # res = 0         # for i in range(len(prices)-1):         #     res = max(res,max(prices[i+1:])-prices[i])         # return res         if not prices:             return 0         res = 0         mi = prices[0]         for i in range(1,len(prices)):             res = max(prices[i]-mi,res)             mi = min(mi,prices[i])         return res

题目：最大子序和

内容： 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。    ‍

程序： class Solution:     def maxSubArray(self, nums: List[int]) -> int:         dp = [0] * len(nums)         dp[0] = nums[0]         for i in range(1,len(nums)):             dp[i] = max(dp[i-1] + nums[i],nums[i])         return max(dp)

题目：打家劫舍

内容： 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。    ‍

程序： class Solution:     def rob(self, nums: List[int]) -> int:         if not nums:             return 0         dp = [[0] * len(nums) for _ in range(2)]         dp[0][0] = nums[0]         dp[1][0] = 0         for i in range(1,len(nums)):             dp[0][i] = max(dp[1][:i])+nums[i]             dp[1][i] = dp[0][i-1]         return max(dp[0][-1],dp[1][-1])