力扣日练-day1

1、二叉树的中序遍历 用递归太慢，故使用颜色标记法，和递归思想差不多

white,gray=0,1   #定义标记颜色
res=[]  
stack=[(white,root)]   #记录标记颜色和节点
while stack:
    color,node = stack.pop()  #循环出站遍历栈中节点
    if node is None:continue   #当前节点为空则循环继续
    if color == white:      #当前节点未遍历则将其与左右孩子节点入栈，注意入栈顺序，和遍历方法有关
        stack.append((white,node.right))
        stack.append((gray,node))
        stack.append((white,node.left))
    else:
        res.append(node.val)
return res
    

 

2、对称二叉树的判断 用递归的思路，判断左子树的左孩子是否等于右子树的右孩子，以及左子树的右孩子是否等于右子树的左孩子

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if root is None:
            return True
        return self.func(root.left,root.right)
    def func(self,left:TreeNode,right:TreeNode):
        if left is None and right is None:
            return True
        if left is None or right is None:
            return False
        if left.val != right.val:
            return False
        return self.func(left.left,right.right) and self.func(left.right,right.left)

 

3、二叉树的最大深度 用递归的思路，求左子树的深度和右子树的深度，取两者最大的一个

  注意：递归内部不用定义变量加加减减，重点在return的条件控制，因为每次返回到上一层的时候是return的值

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if root is None:
            return 0
        leftHeight=self.maxDepth(root.left)
        rightHeight=self.maxDepth(root.right)
        return max(leftHeight,rightHeight)+1

 

4、链表是否有环 很妙的解法，直接修改节点的值进行判断

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        if head is None:
            return False
        h=head
        while h != None:
            if h.val!='':
                h.val=''
            elif h.val=='':
                return True
            h=h.next
        return False
                

 

5、反转二叉树  递归思想，交换每个节点的左右子树

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if root == None:
            return None    #递归出口
        root.left,root.right=root.right,root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root    #上面两个递归结束才执行这个

 

6、str.count("x")可以计算str中x出现的次数

7、对于不关注是否有重复数据的数组可以转化为set数据结构提高查找速度

8、异或操作求两个整数x进制不同的位数，二进制为例，bin(x^y).count('1')

9、滑动窗口练习：

  步骤：定义需要维护的变量—>定义窗口start,end—>更新维护变量—>滑动窗口（分为固定窗口和不定窗口两种情况）

  1.求子数组最大平均值

#求子数组最大平均数
class Solution:
    def findMaxAverage(self, nums: List[int], k: int) -> float:
        sum,max_avg=0,-99999
        start=0
        for end in range(len(nums)):
            sum+=nums[end]
            if end-start+1>=k:
                max_avg=max(max_avg,sum/k)
            if end >=k-1:
                sum-=nums[start]
                start+=1
        return max_avg 
    
    
    
 # Step 1
        # 定义需要维护的变量
        # 本题求最大平均值 (其实就是求最大和)，所以需要定义sum_, 同时定义一个max_avg (初始值为负无穷)
        sum_, max_avg = 0, -math.inf

        # Step 2: 定义窗口的首尾端 (start, end)， 然后滑动窗口
        start = 0
        for end in range(len(nums)):
            # Step 3: 更新需要维护的变量 (sum_, max_avg), 不断把当前值积累到sum_上
            sum_ += nums[end]
            if end - start + 1 == k:
                max_avg = max(max_avg, sum_ / k)

            # Step 4
            # 根据题意可知窗口长度固定，所以用if
            # 窗口首指针前移一个单位保证窗口长度固定, 同时提前更新需要维护的变量 (sum_)
            if end >= k - 1:
                sum_ -= nums[start]
                start += 1
        # Step 5: 返回答案
        return max_avg

 

  2、求不重复最长子串长度

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        #1、定义维护变量,由于需要处理重复数据（当出现重复数据时哈希数组长度小于窗口长度），故需要定义哈希数据结构
        max_len,hashmap=0,{}
        #2、定义窗口头尾
        start=0
        for end in range(len(nums)):
            hashmap[s[end]]=hashmap.get(s[end],0)+1   #不存储重复数据，而是将其出现次数+1
            if len(hashmap)==end-start+1:    #哈希数组长度等于窗口长度，无重复数据
                max_len=max(max_len,end -start+1)
            while len(hashmap)<end-start+1:     #出现重复数据，移动窗口大小
                hashmap[s[start]]-=1
                if hashmap[s[start]]==0:
                    del hashmap[s[start]]
                start+=1
            return max_len