liuxingxing_sun的博客

```pythonclass Solution: def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode: def recur(root,left,right): if left>right: return #递归终止 node=TreeNode(preorder[root]) #根节点为前序遍历.

python反转字符串class Solution: def reverseString(self, s: List[str]) -> None: """ Do not return anything, modify s in-place instead. """ l=0 r=len(s)-1 while l<r: s[l],s[r]=s[r],s[l]

删除链表中的节点class Solution: def deleteNode(self, node): """ :type node: ListNode :rtype: void Do not return anything, modify node in-place instead. """ node.val=node.next.val node.next=node.next.next除自身以外数

2的幂class Solution: def isPowerOfTwo(self, n: int) -> bool: return n>0 and n&(n-1)==0二叉搜索树的最近公共祖先class Solution: def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode': ancestor=

数组中的第K个最大值 class Solution: def findKthLargest(self, nums: List[int], k: int) -> int: n=len(nums) target=n-k left=0 right=n-1 while True: index=self.partition(nums,left,right) if inde

相交链表class Solution: def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode: h1,h2=headA,headB while h1!=h2: h1=h1.next if h1 else headB h2=h2.next if h2 else headA return h1多数元素

LRU缓存机制class ListNode: def __init__(self,key=None,value=None): self.key=key self.value=value self.prev=None self.next=Noneclass LRUCache: def __init__(self, capacity: int): self.capacity=capacity

只出现一次的数字class Solution: def singleNumber(self, nums: List[int]) -> int: return reduce(lambda x,y: x^y, nums) #XOR环形链表 class Solution: def hasCycle(self, head: ListNode) -> bool: if not head or not head.next: retu

买卖股票的最佳时期class Solution: def maxProfit(self, prices: List[int]) -> int: inf=int(1e9) minprice=inf maxProfit=0 for prices in prices: maxProfit=max(prices-minprice,maxProfit) #动态规划，遍历边更新边求差值 mi

合并两个有序数组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. """ p1,p2=m-1,n-1 #倒指针 p=m+n-1 while p1

不同路径class Solution: def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int: f=[[1]*n]+[[1]+[0]*(n-1) for _ in range(m-1)] #设置为1的边界和路径 print(f) for i in range(1,m): for j in range(1,n):

螺旋矩阵class Solution: def spiralOrder(self, matrix: List[List[int]]) -> List[int]: if not matrix: return [] m=len(matrix) #行 n=len(matrix[0]) #列 layer_num=(min(m,n)+1)//2 #有多少层 res_list=[] #保持结果 for l

字符串相乘class Solution: def multiply(self, num1: str, num2: str) -> str: if num1=="0" or num2=="0": return "0" m,n=len(num1),len(num2) ansArr=[0]*(m+n) for i in range(m-1,-1,-1): #从m-1开始，逐一递减，递减至-1的前面那个元素的值

合并K个排序链表class Solution: def mergeKLists(self, lists: List[ListNode]) -> ListNode: n=len(lists) if not lists: return else: return self.merge(lists,0,n-1) def merge(self, lists, L, R): if

最接近的三数之和class Solution: def threeSumClosest(self, nums: List[int], target: int) -> int: nums.sort() n=len(nums) bestNum=nums[0]+nums[1]+nums[2]for i in range(n-2): L=i+1 R=n-1 while L<R:

三数之和：双指针+排序+遍历class Solution: def threeSum(self, nums: List[int]) -> List[List[int]]: res=[] nums.sort() for i in range(len(nums)-2): if(nums[i]>0): return res #空值 if(i>0 and n

整数反转class Solution: def reverse(self, x: int) -> int: ans=0 INTMAX10 = 214748364 INTMIN10 = -214748364 while x: pop=x%10 if x>0 else x%-10 x=x//10 if x>0 else int(x/10) if ans>INTMAX10 or (ans=

两数相加方法一：class Solution: def twoSum(self, nums: List[int], target: int) -> List[int]: n = len(nums) for i in range(n): for j in range(i + 1, n): if nums[i] + nums[j] == target: return

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外，这两个数都不会以 0 开头。示例：输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)输出：7 -> 0 -> 8原因：342 + 465 = 807class Solution: def addTwoNumbe