leetcode

今日学习

字典

给你一个字符串 text，你需要使用 text 中的字母来拼凑尽可能多的单词 “balloon”（气球）。

字符串 text 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 “balloon”

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-number-of-balloons
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def maxNumberOfBalloons(self, text: str) -> int:    
        s='balloon'
        #为每个字符建立字典来解决
        num={}
        for i in text:
            num[i]=0
        for i in s:
            num[i]=0
        for i in text:
            num[i]+=1
        #print(num)
        num['l']=num['l']//2
        num['o']=num['o']//2
        re=[]
        for i in s:
            try:
                re.append(num[i])
            except:
                re.append(0)
       # print(num)
        return min(re)

二叉树：

前中后遍历

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
res=[]
class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        
        if root==None:
            return []
        return self.inorderTraversal(root.left)+[root.val]+self.inorderTraversal(root.right)
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if root==None:
            return []
        return self.postorderTraversal(root.left)+self.postorderTraversal(root.right)+[root.val]

二叉搜索树

将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:

给定有序数组: [-10,-3,0,5,9],

一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：

 0
/ \

-3 9
/ /
-10 5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        mid=0
        mid=(len(nums)//2)
        if not nums:
            return None
        node=TreeNode(nums[mid])
        # print("mid",mid,"node",nums[mid],nums)
        node.left=self.sortedArrayToBST(nums[:mid])
        node.right=self.sortedArrayToBST(nums[mid+1:])
        return node
        #递归法和二分法

缺失的最小正数

给你一个未排序的整数数组，请你找出其中没有出现的最小的正整数。

示例 1:

输入: [1,2,0]
输出: 3

示例 2:

输入: [3,4,-1,1]
输出: 2

示例 3:

输入: [7,8,9,11,12]
输出: 1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/first-missing-positive
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution(object):
    def firstMissingPositive(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
       
        dict={i:i for i in nums if i>0}
       
        for i in range(1,len(dict)+1):
            if i not in dict:
                return i
        return len(dict)+1

正则表达式匹配数字

import re
class Solution(object):
    def isNumber(self, s):
        return bool(re.match(r'\s*[+-]?([\d]+(\.[\d]*)?|\.[\d]+)(e[+-]?[\d]+)? *$', s))
        #贪婪匹配和非贪婪匹配

链表排序 主要用归并法和快慢指针

class Solution {
    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null )
            return head;
        ListNode slow = head,fast = head.next;
        // 快慢指针法，使得slow指向链表的中间节点。
        while(fast!=null && fast.next!=null){
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode last = slow.next;
        slow.next = null;
        ListNode first = sortList(head);
        ListNode second = sortList(last);
        ListNode res = MergeTwoList(first,second);
        return res;
    }
    
    public ListNode MergeTwoList(ListNode list1,ListNode list2){
        ListNode dummpy = new ListNode(-1);
        ListNode tail = dummpy;
        while(list1!=null && list2 !=null){
            if(list1.val < list2.val){
                tail.next = list1;
                list1 = list1.next;
            }else{
                tail.next = list2;
                list2 = list2.next;
            }
            tail = tail.next;
       }
       tail.next = list1!=null?list1:list2;
       return dummpy.next;
    }
}