TommyLiuZ的博客

148. 排序链表1.题目2.官方的解决方案# Definition for singly-linked list.# class ListNode:# def __init__(self, val=0, next=None):# self.val = val# self.next = nextclass Solution: def sortList(self, head: ListNode) -> ListNode:

28. 实现 strStr()1.题目2.我的解决方案不出我所料，超时了class Solution: def strStr(self, haystack: str, needle: str) -> int: if not needle: return 0 i = 0 j = 0 while i < len(haystack): while i

153. 寻找旋转排序数组中的最小值1.题目2.我的解决方案class Solution: def findMin(self, nums: List[int]) -> int: # 使用二分查找 left, right = 0, len(nums) - 1 while left < right: mid = (left+right) //2 if nums[mid] < nums

154. 寻找旋转排序数组中的最小值 II1.题目2.官方的解决方案class Solution: def findMin(self, nums: List[int]) -> int: left, right = 0, len(nums) - 1 while left < right: mid = (left + right) // 2 if nums[mid] < nums[right]:

263. 丑数1.题目2.官方的解决方案我写的是递归，感觉low了class Solution: def isUgly(self, n: int) -> bool: if n <= 0: return False while n%2 == 0: n //= 2 while n%3 == 0: n //= 3 while n

153. 寻找旋转排序数组中的最小值1.题目2.我的解决方案也是官方的解决方案class Solution: def findMin(self, nums: List[int]) -> int: # 使用二分查找 mi = temp = math.inf left = 0 right = len(nums) - 1 while left <= right: mid = (

81. 搜索旋转排序数组 II1.题目2.我的解决方案使用python偷懒class Solution: def search(self, nums: List[int], target: int) -> bool: # 使用python偷懒 if target in nums: return True else: return False排序，使用二分查找class Solutio

33. 搜索旋转排序数组1.题目2.官方的解决方案思路：点击查看class Solution: def search(self, nums: List[int], target: int) -> int: # 使用二分查找法的前提：升序排列 left = 0 right = len(nums) - 1 while left <= right: mid = (left + right) /

80. 删除有序数组中的重复项 II1.题目2.我的解决方案限制i~j的长度为3，比较nums[i]nums[i]nums[i]和nums[j]nums[j]nums[j]，这种情况下相等的话，进行删除删除的数组长度是动态变化的，所以要用len(nums)len(nums)len(nums)对jjj进行判断，防止索引溢出造成的错误class Solution: def removeDuplicates(self, nums: List[int]) -> int:

88. 合并两个有序数组1.题目2.我的解决方案注意：题目中的num1是有固定的内存位置的，计算改变了nums1的指向，最后题目验证的时候还是验证的最初的内存空间，所以必须把最终的答案改到这篇内存空间上才能算是正确的class Solution: def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None: """ Do not return anythin

781. 森林中的兔子1.题目2.我的解决方案这次我应该是用了脑子了，运行时间少于99%的人一定要掌握collection.Counter()的用法class Solution: def numRabbits(self, answers: List[int]) -> int: amount = collections.Counter(answers) # 统计： {数字：个数} num_set = set(answers) # 去重{数

1143. 最长公共子序列1.题目2.官方的解决方案思路：点击查看class Solution: def longestCommonSubsequence(self, text1: str, text2: str) -> int: # 使用动态规划的方法建立二维表 # 将所有的初始值填充为0 n = len(text1) m = len(text2) dp = [[0]*(m + 1) for _ i

1006. 笨阶乘1.题目2.我的解决方案我是智障，从左到右按照顺序进行计算的3.官方的解决方案数学的算术运算借助栈完成class Solution: def clumsy(self, N: int) -> int: # 注意：是先计算乘除，再计算加减（不要向智障一样从左到右按顺序进行计算） # python的//是向下取整： -3//2 = -2 # c++的取整是直接抛弃小数部分：-3/2 = -1 # 地

90. 子集 II1.题目2.官方的解决方案解法一：使用itertools.combinations(list, n)class Solution: def subsetsWithDup(self, nums: List[int]) -> List[List[int]]: # 解法一： 使用组合函数和extend函数 # (了解该方法即可，一般考核的时候不要尝试) res = [] nums.sort() #关键行

1512.好数对的数目1.题目2.我的解决方案先排序利用while循环,ls.count(nums[i])统计个数,然后利用数学中的组合公式计算要注意结果在累加过程中索引是跳跃性变化的时间复杂度:O(n)O(n)O(n)空间复杂度:O(n)O(n)O(n)3.官方的解决方案反思:思路和我的是一样的,但是更善于使用现成的工具collections.Counter使用起来更方便class Solution: def numIdenticalPairs(self, nums

74. 搜索二维矩阵1.题目2.我的解决方案和剑指offer的04题是一样的class Solution: def searchMatrix(self, matrix: List[List[int]], target: int) -> bool: i, j = 0, len(matrix[0])-1 while j>=0 and i<len(matrix): # 注意分支语句的正确使用 if target &

190. 颠倒二进制位1.题目2.我的解决方案一种笨办法class Solution: def reverseBits(self, n: int) -> int: binary = list(bin(n)) binary.pop(0) binary.pop(0) # 去除前缀 for i in range(32-len(binary)): # 将转换过程中缺失的0补齐 binary.ins

173. 二叉搜索树迭代器1.题目2.我的解决方案题目本身不太好理解二叉树题目已经给出，所以只需要root初始化其他就是简单的中序遍历上附加的操作# Definition for a binary tree node.# class TreeNode:# def __init__(self, val=0, left=None, right=None):# self.val = val# self.left = left# s

61. 旋转链表1.题目2.我的解决方案思路：形成单向循环链表在length-k处断开# Definition for singly-linked list.# class ListNode:# def __init__(self, val=0, next=None):# self.val = val# self.next = nextclass Solution: def rotateRight(self, head: ListNo

238.除以自身以外数组的乘积1.题目2.我的解决方案规定了不用除法,我会用二重循环和将当前数字置换到第一位的方法时间复杂度:O(n)O(n)O(n)空间复杂度:O(n)O(n)O(n)3.官方的解决方案思路:总体上使用一个L数组存储第i元素左边部分的乘积,使用R元素存储右边部分的乘积为了节省空间,使用res做L数组,R数组改用逆置和循环的方式使用r存储,不用再使用数组存储class Solution: def productExceptSelf(self, nums:

114.二叉树展开为链表1.题目2.我的解决方案使用前序遍历,将其转化成链表,然后再将其构造成题目需要的二叉树思路简单,代码不再赘述时间复杂度:O(n)O(n)O(n)空间复杂度:O(n)O(n)O(n)3.官方的解决方案更精妙的解决方案# Definition for a binary tree node.# class TreeNode:# def __init__(self, val=0, left=None, right=None):# se

83. 删除排序链表中的重复元素1.题目2.我的解决方案# Definition for singly-linked list.# class ListNode:# def __init__(self, val=0, next=None):# self.val = val# self.next = nextclass Solution: def deleteDuplicates(self, head: ListNode) -> List

771.宝石与石头1.题目2.我的解决方案简单题目，没有啥好说的class Solution: def numJewelsInStones(self, jewels: str, stones: str) -> int: res = 0 for i in range(len(jewels)): res += stones.count(jewels[i]) return res时间复杂度:O(n)O(n)O

1672. 最富有客户的资产总量1.题目2.我的解决方案使用python内置函数非常简单class Solution: def maximumWealth(self, accounts: List[List[int]]) -> int: res = -math.inf for i in range(len(accounts)): money = sum(accounts[i]) res = max(r

82. 删除排序链表中的重复元素 II1.题目2.我的解决方案没有想到哑结点这个办法其他的思路都是和官方题解相同到头来用了三个指针和很多的分支语句，但是因为删除head带来的干扰，始终没有通过所有的测试用例3.官方的解决方案# Definition for singly-linked list.# class ListNode:# def __init__(self, val=0, next=None):# self.val = val# se

1603. 设计停车系统1.题目2.我的解决方案很难相信这个是leetcode的题目class ParkingSystem: def __init__(self, big: int, medium: int, small: int): self.big = big self.medium = medium self.small = small def addCar(self, carType: int) -> bool

39.组合总和1.题目2.我的解决方案自己写的回溯算法，虽然进行了剪枝，但是从运行时间上来看，效果还是不行class Solution: def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]: # 使用回溯法+剪枝函数 def dfs(candidates, target, begin, path, res): if p

1480.一维数组的动态和1.题目2.我的解决方案简单，没什么说的class Solution: def runningSum(self, nums: List[int]) -> List[int]: res = [nums[0]] for i in range(1,len(nums)): res.append(res[i-1] + nums[i]) return res时间复杂度:O(n)O(n)O(n)

191.位1的个数1.题目2.我的解决方案直接统计class Solution: def hammingWeight(self, n: int) -> int: s = bin(n) # 读入是十进制，还是需要转换成二进制 return s.count('1')时间复杂度:O(n)O(n)O(n)空间复杂度:O(1)O(1)O(1)固定公式法class Solution: def hammingWeight(self, n: i

48.旋转图像1.题目2.我的解决方案原地旋转矩阵并没有做到发现了矩阵索引变化的规律发现了要区奇偶情况发现了周期性，但是后来又忽略了这一点3.官方的解决方案点击学习重点掌握枚举个数的计算掌握通过数学运算将奇数和偶数统一在一起class Solution:def rotate(self, matrix: List[List[int]]) -> None: n = len(matrix) for i in range(n // 2): # 偶数正常操作，奇数就

406.根据身高重建队列1.题目2.我的解决方案我是没有想到两个方向不一样的排序这种情况的3.官方的解决方案class Solution: def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]: # 套路，两个关键字，一个正向排序，一个反向排序（只要是相反的就行） people.sort(key = lambda x: (-x[0], x[1])) # 这个实际

22.括号生成1.题目2.我的解决方案这道题，我真的不会，，，，真的，越刷题，打击越大3.官方的解决方案暴力法（回溯法，没有剪枝）class Solution: def generateParenthesis(self, n: int) -> List[str]: # 暴力法 def generate(bracket): if len(bracket) == 2*n: if valid(bra

94.二叉树的中序遍历1.题目2.我的解决方案使用递归解决，这个属于基础题目# Definition for a binary tree node.# class TreeNode:# def __init__(self, val=0, left=None, right=None):# self.val = val# self.left = left# self.right = rightclass Solution:

46.全排列1.题目2.我的解决方案想到了用回溯，但是在调整顺序方面出了问题3.官方的解决方案class Solution: def permute(self, nums: List[int]) -> List[List[int]]: # 类似于子集问题：考虑使用回溯算法:深度优先遍历，所有的结点就是答案 def dfs(begin): if begin == length: # 1.叶子结点的处理方法

338.比特位计数1.题目2.我的解决方案忽略进阶要求使用python解决属于简单题目class Solution: def countBits(self, num: int) -> List[int]: res = [] for i in range(num+1): ls = list(bin(i)) ls.pop(0) # 去除二进制前缀0 ls.pop(0) #

78.子集1.题目2.我的解决方案太菜了，这道题用的思路不太会3.官方的解决方案回溯法:从选择和不选择的角度出发看视频：点击查看class Solution: def subsets(self, nums: List[int]) -> List[List[int]]: # 采用回溯法，使用深度优先遍历 # 二叉树所有的叶子结点都是问题的解 def dfs(nums, length, index, path, res):

20.有效括号1.题目2.我的解决方案没想出来，想到了用字典和遇到右括号就匹配这两个思路，但是没有想到用栈的数据结构3.官方的解决方案class Solution: def isValid(self, s: str) -> bool: if len(s)%2 != 0: # 奇数个数直接不匹配 return False # 使用栈结构 pairs = {'}':'{', ')':'(', ']':'['

234.回文链表1.题目2.我的解决方案想不出来空间复杂度为O(1)的情况O(1)的情况O(1)的情况3.官方的解决方案# Definition for singly-linked list.# class ListNode:# def __init__(self, val=0, next=None):# self.val = val# self.next = nextclass Solution: def isPalindrome(se

141.环形链表1.题目2.我的解决方案# Definition for singly-linked list.# class ListNode:# def __init__(self, x):# self.val = x# self.next = Noneclass Solution: def hasCycle(self, head: ListNode) -> bool: if not head: # 空链表和

70.爬楼梯1.题目2.我的解决方案思路：将前5个结果写出来，发现符合斐波那契数列的规律class Solution: def climbStairs(self, n: int) -> int: # 结果符合斐波那契数列 if n == 0: return 0 if n ==1: return 1 if n == 2: return 2