weixin_45547419的博客

学会了在文件夹中打开cmd。即：在文件地址栏搜索cmd即可。学会了用tensorboard看结果，把tensorboard.exe的路径加入到环境变量中。会用了一点点latex。还学会了克隆clone，绿色CODE下拉框里就有clone，fork也行。...

前提：python3.8.8，已安装anaconda，pytorch.1.9.0打开anaconda prompt，输入：pip install tensorflow==2.6.0 -i https://pypi.doubanio.com/simple --user即可。

328. 奇偶链表法一：python–3指针插入法# Definition for singly-linked list.# class ListNode:# def __init__(self, val=0, next=None):# self.val = val# self.next = nextclass Solution: def oddEvenList(self, head: ListNode) -> ListNode:

5. 最长回文子串中心拓展法class Solution: def longestPalindrome(self, s: str) -> str: n=len(s) if n<2: return s maxlength=0 for i in range(n): left,right=self.islongest(i,i,s) left2,right2

15. 三数之和注意点：超时原因pythonclass Solution: def threeSum(self, nums: List[int]) -> List[List[int]]: if len(nums)<3: return [] res=[] nums.sort() n=len(nums) for i in range(n): if i==0 o

268. 丢失的数字法一：异或法执行用时： 44 ms , 在所有 Python3 提交中击败了85.00% 的用户内存消耗：15.9 MB , 在所有 Python3 提交中击败了 17.21% 的用户class Solution: def missingNumber(self, nums: List[int]) -> int: missing=len(nums) for i,num in enumerate(nums):

118. 杨辉三角执行用时：52 ms, 在所有 Python3 提交中击败了6.34%的用户内存消耗：14.8 MB, 在所有 Python3 提交中击败了73.25%的用户class Solution: def generate(self, numRows: int) -> List[List[int]]: res=[] if numRows==1: return [[1]] res.append([1])

190. 颠倒二进制位法一：逐步左移相加执行用时：44 ms, 在所有 Python3 提交中击败了52.29%的用户内存消耗：14.6 MB, 在所有 Python3 提交中击败了85.37%的用户class Solution: def reverseBits(self, n: int) -> int: res=0 for i in range(32): res<<=1 res+=n&am

461. 汉明距离法一：与1，异或，右移执行用时： 36 ms , 在所有 Python3 提交中击败了84.20% 的用户内存消耗：14.6 MB , 在所有 Python3 提交中击败了 94.88% 的用户class Solution: def hammingDistance(self, x: int, y: int) -> int: #右移与1 a=0 for i in range(32): a+=((

191. 位1的个数普通位运算44 ms 14.5 MB Python3return sum(1 for i in range(32) if n&(1<<i))位运算优化44 ms 14.8 MB Python3class Solution: def hammingWeight(self, n: int) -> int: res=0 while n>0: n&=(n-1)

326. 3的幂对数计算法执行用时：76 ms, 在所有 Python3 提交中击败了94.26%的用户内存消耗：14.7 MB, 在所有 Python3提交中击败了85.61%的用户class Solution: def isPowerOfThree(self, n: int) -> bool: if n<=0: return False e=log10(n)/log10(3) return floor

204. 计数质数法一：暴力枚举超时class Solution: def countPrimes(self, n: int) -> int: #暴力枚举超时 def isprime(x): if x==1: return False for i in range(2,int(sqrt(x))+1): if x%i==0

155. 最小栈并行两个栈注意：1.python最后一个元素下标。list[-1]2.python最大值math.inf执行用时：60 ms, 在所有 Python3 提交中击败了92.45%的用户内存消耗：18 MB, 在所有 Python3 提交中击败了22.76%的用户class MinStack: def __init__(self): """ initialize your data structure here. """

384. 打乱数组法一：暴力洗牌法不懂：self.array已经是list形式了，为什么aux还要再list一次呢？以下几个list少一个，换换地方都不行。执行用时：212 ms, 在所有 Python3 提交中击败了74.98%的用户内存消耗：20.2 MB, 在所有 Python3 提交中击败了45.17%的用户class Solution: def __init__(self, nums: List[int]): self.array=list(nums)#十分

121. 买卖股票的最佳时机法一：max_ending_here,max_so_far执行用时：144 ms, 在所有 Python3 提交中击败了94.71%的用户内存消耗：23.5 MB, 在所有 Python3 提交中击败了63.57%的用户class Solution: def maxProfit(self, prices: List[int]) -> int: mn=prices[0] max_ending_here,max_so_far=

70.爬楼梯法一：递归+记忆执行用时：40 ms, 在所有 Python3 提交中击败了58.96%的用户内存消耗：15 MB, 在所有 Python3 提交中击败了5.11%的用户class Solution: def climbStairs(self, n: int) -> int: def dfs(n,memo): if n==0 or n==1: memo[n]=1 if mem

19. 删除链表的倒数第 N 个结点36 ms 14.8 MB Python3# Definition for singly-linked list.# class ListNode:# def __init__(self, val=0, next=None):# self.val = val# self.next = nextclass Solution: def removeNthFromEnd(self, head: ListNode,

102. 二叉树的层序遍历法一：C++队列执行用时： 0 ms , 在所有 C++ 提交中击败了100.00% 的用户内存消耗：12.1 MB , 在所有 C++ 提交中击败了 69.53% 的用/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0)

101. 对称二叉树法一：中序遍历有3个样例不能通过测试。其中一个是[1,2,2,2,null,2]预期：False返回：True# 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

98. 验证二叉搜索树法一：中序遍历执行用时： 52 ms , 在所有 Python3 提交中击败了76.78% 的用户内存消耗：17.2 MB , 在所有 Python3 提交中击败了48.72% 的用户用到了栈，其实就是python的列表# Definition for a binary tree node.# class TreeNode:# def __init__(self, val=0, left=None, right=None):# self.va

141.环形链表快慢指针–龟兔赛跑执行用时：64 ms, 在所有 Python3 提交中击败了66.76%的用户内存消耗：18.1 MB, 在所有 Python3 提交中击败了54.61%的用户# Definition for singly-linked list.# class ListNode:# def __init__(self, x):# self.val = x# self.next = Noneclass Solution:

234.回文链表法一：截断+反转链表改进：可反转后半段，还可快指针走两步，慢指针走一步来找到中点。执行用时： 668 ms , 在所有 Python3 提交中击败了 77.21% 的用户内存消耗： 32.6 MB , 在所有 Python3 提交中击败了77.55% 的用户def isPalindrome( head: ListNode) -> bool: if head==None or head.next==None: return True #统计节

8. 字符串转换整数 (atoi)法一：if-else题目没审清导致细节问题多。执行用时： 56 ms , 在所有 Python3 提交中击败了14.32% 的用户内存消耗：14.8 MB , 在所有 Python3 提交中击败了90.40% 的用添加对0的判断，性能提高。执行用时： 40 ms , 在所有 Python3 提交中击败了86.12% 的用户内存消耗：14.8 MB , 在所有 Python3 提交中击败了85.19% 的用户class Solution: de

法一：双指针法超时。位置3没写： i+=1 j-=1把i=0 j=len(s)-1从位置1 移动到位置2，不然循环结束后 i==26执行用时： 64 ms , 在所有 Python3 提交中击败了37.76% 的用户内存消耗： 15 MB , 在所有 Python3 提交中击败了87.60% 的用户class Solution: def isPalindrome(self, s: str) -> bool: #位置1 d={} fo

242. 有效的字母异位词法一：循环删除法性能极差执行用时： 2040 ms , 在所有 Python3 提交中击败了 5.18% 的用户内存消耗： 16 MB , 在所有 Python3 提交中击败了 5.01% 的用户class Solution: def isAnagram(self, s: str, t: str) -> bool: s=list(s) t=list(t) for i in s: f

字符串中的第一个唯一字符执行用时： 132 ms , 在所有 Python3 提交中击败了52.68% 的用户内存消耗： 15 MB , 在所有 Python3 提交中击败了63.80% 的用户法一：遍历字典计数法。class Solution: def firstUniqChar(self, s: str) -> int: d={} for i in range(len(s)): d[s[i]]=d.get(s[i],0)+

反转字符串执行用时： 48 ms , 在所有 Python3 提交中击败了76.78% 的用户内存消耗： 19 MB , 在所有 Python3 提交中击败了80.73% 的用户class Solution: def reverseString(self, s: List[str]) -> None: """ Do not return anything, modify s in-place instead. """ f

48.旋转图像法一：reverse()函数，zip()函数执行用时：44 ms, 在所有 Python3 提交中击败了33.42%的用户内存消耗：14.7 MB, 在所有 Python3提交中击败了84.39%的用户class Solution: def rotate(self, matrix: List[List[int]]) -> None: """ Do not return anything, modify matrix in-place i

36.有效的数独法一：遍历存储9宫格及其坐标。时间优秀，内存极差。48 ms 15.1 MB Python3class Solution: def isValidSudoku(self, board: List[List[str]]) -> bool: op=[[],[],[],[],[],[],[],[],[]] do={} digit=list(str(i) for i in range(1,10)) for i in

283.移动零法一：remove（0）性能差。Python3：执行用时：120 ms 内存消耗：15.4 MBclass Solution: def moveZeroes(self, nums: List[int]) -> None: """ Do not return anything, modify nums in-place instead. """ count=0 while 0 in nums:

66.加一法一：性能较优Python3: 执行用时：32 ms 内存消耗：14.8 MBclass Solution: def plusOne(self, digits: List[int]) -> List[int]: carry=1 digits.reverse() for i in range(len(digits)): val=carry+digits[i] carry,digits[

350. 两个数组的交集 II法一：字典算单词，集合算累计。44 ms 15.1 MB Python3时间性能可以，存储极差。没什么技巧可言。class Solution: def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]: dnum1={} dnum2={} for i in nums1: dnum1[i]=dnum1.get

存在重复元素Python3: 60 ms 20.2 MBclass Solution: def containsDuplicate(self, nums: List[int]) -> bool: s=set(nums) if len(nums)>len(s): return True """ #一个测试用例超时 for i in nums: if nums

只出现一次的数字法一：空间复杂度：O(n)Python3: 976 ms 16.6 MBclass Solution: def singleNumber(self, nums: List[int]) -> int: if len(nums)==1: return nums[0] hashtable=[] for i in range(len(nums)): if nums[i] not i

189.旋转数组法一：reverse逆转函数注意：不是nums数组将指向新的地址。不是原地反转。"""nums=eval(input())k=int(input())"""k%=len(nums)print(id(nums))nums[k:].reverse()nums=nums[k:]+nums[:k]print(id(nums))print(nums)法二：自己的笨方法不更改nums数组地址，时间复杂度O(n),空间复杂度O(n)Python3: 执行用时: 112 m

买卖股票的最佳时机 IIPython3： 执行用时: 40 ms 内存消耗: 15.5 MBclass Solution: def maxProfit(self, prices: List[int]) -> int: earn=0 buy=0 sell=0 for i in range(1,len(prices)): if prices[i]-prices[i-1]>0:

3.无重复字符的最长字串法一：动态规划衍生法法一：动态规划衍生 性能一般：224 ms 15 MB Python3思路：以节点为终点遍历。改进：以tmp=tmp[tmp.find(s[i])+1:]+s[i] 替代for循环。性能较优：64 ms 15 MB Python3class Solution: def lengthOfLongestSubstring(self, s: str) -> int: if s=='': return 0

53.最大子序和法一：52 ms 15.2 MB Python3思路：滑动窗口，i，j，记录当前子序端点，lsum：当前子序和。if lsum<0:可理解为，一个小于0的序列没资格加入其它序列，没资格与后续序列拼接。class Solution: def maxSubArray(self, nums: List[int]) -> int: if len(nums)==1: return nums[0] i,j=0,0

38.外观数列class Solution: def countAndSay(self, n: int) -> str: if n==1: return '1' s=self.countAndSay(n-1) i=0 strs='' while True: count=0 while i+count<len(s) and s[i+cou

35.搜索插入位置32 ms 15.3 MBclass Solution: def searchInsert(self, nums: List[int], target: int) -> int: if target in nums: return nums.index(target) for i in nums: if i>target: return nums.inde