06 2021 档案
摘要：递归找最小 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left #
阅读全文
摘要：递归 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # se
阅读全文
摘要：1）开挂调库 import itertools class Solution: def permute(self, nums: List[int]) -> List[List[int]]: n = len(nums) result = [] for i in itertools.permutatio
阅读全文
摘要：左括号才能放右括号，参考他人答案。 class Solution: def generateParenthesis(self, n: int) -> List[str]: res = [] def dfs(tmp, left, right): if len(tmp) == 2 * n: res.ap
阅读全文
摘要：逐个遍历字典，逐个匹配 class Solution: def letterCombinations(self, digits: str) -> List[str]: if not digits: return [] dic = {'2':['a','b','c'], '3':['d','e','f
阅读全文
摘要：不会，暂时先抄一下。 主要是四领域置零直至领域无1，递归 class Solution: def numIslands(self, grid: List[List[str]]) -> int: counter = 0 for i in range(len(grid)): for j in range
阅读全文
摘要：逐行入栈，排序后直接输出第k小的数据 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.
阅读全文
摘要：设置p为根节点，设置判断count，长度为当前层长度 逐个遍历节点，若左右节点存在则加入，随后删除头节点。 当count=1时，为当前层最后一个节点的时候，p指向None。删除头节点，p指向下一层开头 若count != 1，则正常向后指 """ # Definition for a Node. c
阅读全文
摘要：由前序的特点，第一个必定是root结点 由中序的特点，根节点左侧为左子树，右侧为右子树。 递归流程为： 1）从preorder中找到根节点 2）从inorder中拆分出左右子树 3）按长度在preorder中继续找到左右子树的preorder进行递归建树 # Definition for a bin
阅读全文
摘要：逐层保存结果，然后判断奇数层反向。 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.l
阅读全文
摘要：1）递归。先左后根再由 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left =
阅读全文
摘要：都有相同的tail。则先将列表变为长短一致。 然后逐个前进。找到相同节点。 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = Non
阅读全文
摘要：若链表长度小于3，则不用重排 否则单独提取出奇偶链表，最后奇链表.next为偶链表head # Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # self.va
阅读全文
摘要：先写两个函数： 1）getListNum:因为链表是逆序数字，所以链表逐个入栈，然后出栈组成顺序数字。 2) List2Link:将数字转换成列表然后从尾部逐个相连。 # Definition for singly-linked list. # class ListNode: # def __ini
阅读全文
摘要：逐个遍历，找到满足大于第一第二的值。否则判断替换 空间复杂度较高 class Solution: def increasingTriplet(self, nums: List[int]) -> bool: if len(nums)<3: return False mini = 2 ** 31 - 1
阅读全文
摘要：1）逐个遍历，向两边扩散。分单一扩散（奇数），和双字符扩散（偶数）两种情况考虑 时间复杂度较高 class Solution: def longestPalindrome(self, s: str) -> str: length = len(s) maxlength = 0 for i in ran
阅读全文
摘要：1）双指针，若fast不存在temp中，则加入。若存在则删除首位，slow前进一位。 保留一个临时变量保存最大长度。 时间复杂度O(n) class Solution: def lengthOfLongestSubstring(self, s: str) -> int: length = len(s
阅读全文
摘要：1）先对所有字符串重排序，然后取set获得总共的分组个数。再逐个判断加入。时间复杂度太高了 class Solution: def groupAnagrams(self, strs: List[str]) -> List[List[str]]: def so(x): x= sorted(x) ret
阅读全文
摘要：笨比方法，空间复杂度较高 1）逐行遍历，发现0记录列的位置，然后当前行全为0。最后再遍历一次，每行的对应列也置0 class Solution: def setZeroes(self, matrix: List[List[int]]) -> None: """ Do not return anyth
阅读全文
摘要：想了很久，双指针的方法一直超时。可能是python的特性。 主要有两个问题：1）重复列表判断；2）遍历 方法： 1）暴力三重for循环，O（n^3)，会超时 2）先排序，然后双指针 class Solution: def threeSum(self, nums: List[int]) -> List
阅读全文
摘要：1）获取未缺失数字的列表，逐个对比（很慢！） class Solution: def missingNumber(self, nums: List[int]) -> int: reallist = [i for i in range(len(nums)+1)] for i in reallist:
阅读全文
摘要：1）栈思路 遇见左括号，则对应右括号入栈 遇右括号：①若栈不为空，则与栈顶比较，相同则continue，不同则返回False ②若栈为空，直接返回False class Solution: def isValid(self, s: str) -> bool: if len(s) % 2 == 1:
阅读全文
摘要：1）普通写法，从第三行开始，计算中间元素，首位补1。空间复杂度较高 class Solution: def generate(self, numRows: int) -> List[List[int]]: if numRows == 1: return [[1]] if numRows == 2:
阅读全文
摘要：1）转换二进制取不为零开始的字符串，补全反转输出。 class Solution: def reverseBits(self, n: int) -> int: t = bin(n)[2:] t = '0' * (32 - len(t)) + t return int(t[::-1],2) 2）移位，
阅读全文
摘要：1）取异或，然后计算1的个数 class Solution: def hammingDistance(self, x: int, y: int) -> int: t = x^y count = 0 while t: count += 1 t = t& t-1 return count
阅读全文
摘要：1）调库count class Solution: def hammingWeight(self, n: int) -> int: return bin(n).count('1') 2)按位与，n&n-1等于去掉倒数的第一个1 class Solution: def hammingWeight(se
阅读全文
摘要：1)倒序计算，如果结果大于标准数四倍，则超出，需要减去。空间复杂度大 class Solution: def romanToInt(self, s: str) -> int: roman_num = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, '
阅读全文
摘要：1）递归/循环，时间复杂度较高，重复计算 class Solution: def isPowerOfThree(self, n: int) -> bool: #递归 if n == 0: return False if n == 1: return True if (n / 3 )== 1 : re
阅读全文
摘要：1）逐个判断，太慢了！ 2）埃氏筛法，从2开始，1不是质数 class Solution: def countPrimes(self, n: int) -> int: isNumPrimes = [True] * n count = 0 for i in range(2, n): if isNumP
阅读全文
摘要：?这是啥算法题。。 逐个判断写个循环即可 class Solution: def fizzBuzz(self, n: int) -> List[str]: result = [] for i in range(1,n+1): if i % 3 == 0 and i % 5 == 0 : result
阅读全文
摘要：1）直接用list，但是时间复杂度很高 class MinStack: def __init__(self): """ initialize your data structure here. """ self.stack = list() def push(self, val: int) -> N
阅读全文
摘要：简单 注意origin不能保持一样，否则random的时候同时修改原始属性 import random class Solution: def __init__(self, nums: List[int]): self.origin = nums[:] self.temp = nums def re
阅读全文
摘要：从第三项开始，判断是第i项加上之前的i-2的和大还是i-1的和大 class Solution: def rob(self, nums: List[int]) -> int: if not nums: return 0 if len(nums) == 1: return nums[0] profit
阅读全文
摘要：逐个求，保存最大和。 如果前序和小于0则舍弃，始终以正值优先。 class Solution: def maxSubArray(self, nums: List[int]) -> int: cur = nums[0] maximum = nums[0] for i in range(1,len(nu
阅读全文
摘要：从头遍历到尾两两计算，遇到最小换最小，逐个计算大利润，遇到大利润保存大利润 类似栈 效率高但是耗内存 class Solution: def maxProfit(self, prices: List[int]) -> int: if len(prices) <= 1: return 0 minimu
阅读全文
摘要：1--1种 2--2种 3--3种 4--5种 5--8种 ………… 写一写发现类似斐波那契数列，后一项等于前两项之和 class Solution: def climbStairs(self, n: int) -> int: if n <= 2: return n a = 1 b = 2 whil
阅读全文
摘要：画一个列表自己试试，二分法 # The isBadVersion API is already defined for you. # @param version, an integer # @return an integer # def isBadVersion(version): class
阅读全文
摘要：看似简单，实际上想了挺久的 1）内置api方法 class Solution: def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None: """ Do not return anything, modif
阅读全文
摘要：恢复内容开始 null 恢复内容结束
阅读全文
摘要：就是BFS，同时把每层的值作为列表保存 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self
阅读全文
摘要：1)递归，判断是否两个都是空节点。 如果只有一个空，则False 如果都不空但不相等，则False 否则返回左节点的左节点，右节点的右节点。 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val
阅读全文
摘要：中序遍历递归写法 思考良久写不出来，借鉴了网上的写法 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val
阅读全文
摘要：1)BFS，效率一般，内存较优 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.lef
阅读全文
摘要：1)逐个入栈，检查是否有重复元素出现（效率极低）（类似hashmap) # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None
阅读全文
摘要：1)用栈，再利用字符串的思路二分对比（或者利用出栈.pop())，双指针也行。（时间空间都效率太低） # Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # se
阅读全文
摘要：1） 两个列表逐个对比，谁小接谁。 当有列表遍历结束时，则剩下全部列表接在末尾 # Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # self.val = va
阅读全文
摘要：第一轮解法： 1）双指针，先给定尾部为空，然后逐个出栈 # Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # self.val = val # self.nex
阅读全文
摘要：第一轮： 方法1：求长度，减去n得到被删除节点的前一个节点，直接跨越链接。若num=0则删除的是首节点 # Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # s
阅读全文
摘要：？这是算法题吗 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution: def deleteNo
阅读全文
浙公网安备 33010602011771号