leetcode刷题Day5

leetcode刷题Day5
38.Excel表列序号
给你一个字符串 columnTitle ，表示 Excel 表格中的列名称。返回该列名称对应的列序号 。

• 示例：输入: columnTitle = “A”; 输出: 1

class Solution:
    def titleToNumber(self, columnTitle: str) -> int:
        result = 0
        for i in columnTitle:
            result = result * 26 + ord(i) - ord("A") + 1
        return result

39.颠倒二进制位
颠倒给定的 32 位无符号整数的二进制位。

• 示例：输入：n = 00000010100101000001111010011100
• 输出：964176192 (00111001011110000010100101000000)
• 解释：输入的二进制串00000010100101000001111010011100 表示无符号整数 43261596，
  因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。

class Solution:
    def reverseBits(self, n: int) -> int:
        result = 0
        for i in range(32):
            result = (result << 1) + (n & 1)
            n >>= 1
        return result

注：n从高位往左，result从低位往右。

40.移除链表元素
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足Node.val == val 的节点，并返回新的头节点 。

• 示例：输入：head = [1,2,6,3,4,5,6], val = 6 ; 输出：[1,2,3,4,5]

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy_node = ListNode(0) 
        dummy_node.next = head  # 创建一个虚拟头节点
        cur_node = dummy_node
        while cur_node.next:
            if cur_node.next.val == val:
                cur_node.next = cur_node.next.next
            else:
                cur_node = cur_node.next
        return dummy_node.next # 虚拟头节点的下一节点才是真正的头节点

41.同构字符串
给定两个字符串 s 和 t ，判断它们是否是同构的。
如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。
每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

• 示例：输入：s = “egg”, t = “add”; 输出：true

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:
        if len(s) != len(t): return False
        s_map, t_map = {}, {}
        for i in range(len(s)):
            s_char = s[i]
            t_char = t[i]
            if s_char in s_map:
                if s_map[s_char] != t_char:
                    return False
            else:
                if t_char in t_map:
                    return False
                s_map[s_char] = t_char
                t_map[t_char] = s_char
        return True

42.反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

• 示例：输入：head = [1,2,3,4,5]； 输出：[5,4,3,2,1]

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        stack = list()
        h = head
        while h:
            stack.append(h)
            h = h.next
        reverse = ListNode()
        dummy = reverse
        while stack:
            node = stack.pop()
            node.next = None
            dummy.next = node
            dummy = dummy.next
        return reverse.next

43.存在重复元素II
给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。

• 示例：输入：nums = [1,2,3,1], k = 3; 输出：true

class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
        dict_hash = {}
        for i in range(len(nums)):
            if nums[i] in dict_hash and abs(i - dict_hash[nums[i]]) <= k:
                return True
            else:
                dict_hash[nums[i]] = i
        return False

44.完全二叉树的节点个数
给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。
完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^h 个节点。

• 示例：输入：root = [1,2,3,4,5,6]; 输出：6

class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        if not root: return 0
        nodes = self.inorderTraversal(root)
        return len(nodes)
        

    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root is None: return []
        nodes = []
        nodes.append(root.val)
        nodes += self.inorderTraversal(root.left)
        nodes += self.inorderTraversal(root.right)
        return nodes

45.翻转二叉树
给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

• 示例：输入：root = [4,2,7,1,3,6,9]; 输出：[4,7,2,9,6,3,1]

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if root is None: return None

        root.left, root.right = root.right, root.left
        root.left = self.invertTree(root.left)
        root.right = self.invertTree(root.right)
        return root

46.2的幂
给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true ；否则，返回 false 。
如果存在一个整数 x 使得 n == 2^x ，则认为 n 是 2 的幂次方。

• 示例：输入：n = 1; 输出：true; 解释：20 = 1

import math
class Solution:
    def isPowerOfTwo(self, n: int) -> bool:
        if n <= 0: return False
        return math.log2(n).is_integer()

47.回文链表
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

• 示例：输入：head = [1,2,2,1]; 输出：true

class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        list1, list2 = [], []
        while head:
            list1.append(head.val)
            list2.append(head.val)
            head = head.next
        list2.reverse()
        return list1 == list2

48.有效的字母异位词
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

• 示例：输入: s = “anagram”, t = “nagaram”； 输出: true

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        if len(s) != len(t): return False
        s_count = collections.Counter(s)
        t_count = collections.Counter(t)
        return s_count == t_count