leetcode-指剑offer

• 剑指 Offer 05. 替换空格
• 剑指 Offer 15. 二进制中1的个数
• 剑指 Offer 10- II. 青蛙跳台阶问题
• 剑指 Offer 17. 打印从1到最大的n位数
• 剑指 Offer 18. 删除链表的节点
• 剑指 Offer 21. 调整数组顺序使奇数位于偶数前面
• 剑指 Offer 27. 二叉树的镜像
• 剑指 Offer 28. 对称的二叉树
• 剑指 Offer 30. 包含min函数的栈
• 剑指 Offer 39. 数组中出现次数超过一半的数字
• 剑指 Offer 50. 第一个只出现一次的字符

剑指 Offer 05. 替换空格

class Solution:
    def replaceSpace(self, s: str) -> str:
        res = []
        for i in s:
            if i == ' ':
                res.append('%20')
            else:
                res.append(i)
        return ''.join(res)

剑指 Offer 15. 二进制中1的个数

class Solution:
    def hammingWeight(self, n: int) -> int:
        res = 0
        while n:
            res+=1
            n&=n-1 
            # n-1 会让最右边（最小的）1变成0，比如1000-1=0111
            # n还是原来的1000
            # & 是按位运算符，1&1=1，其他是0
            #因此n & n-1 = 0000 会把原本的1消掉，而且会把-1之后多出来的1消掉，不会影响下一次计算
            #每次循环就会消掉一个1，因此只用循环1的个数次数，最后n会变成全0
        return res

剑指 Offer 10- II. 青蛙跳台阶问题

class Solution:
    def numWays(self, n: int) -> int:        
        dp1 = 1 # 代表有0阶的时候的跳法
        dp2 = 1 #代表有1阶的时候的跳法
        for i in range(n):
            dp1, dp2 = dp2, dp1+dp2 
            # i = 0 时，dp1代表1阶的跳法，dp2代表2阶的跳法
            # i = 1时，dp1代表2阶的跳法，dp2代表3阶的跳法
            # i = n-1时，dp1代表n阶的跳法，dp2代表n+1阶的跳法，
        return dp1 % 1000000007 # 返回dp1 mod 1e9+7

剑指 Offer 17. 打印从1到最大的n位数

class Solution:
    def printNumbers(self, n: int) -> List[int]:
        return list(range(1,10**n))

剑指 Offer 18. 删除链表的节点

class Solution:
    def deleteNode(self, head: ListNode, val: int) -> ListNode:
        if head.val == val: # 单独考虑第一位的值，因为接下来是将cur作为下一个考虑的点
            return head.next
        pre, cur = head, head.next
        while cur and cur.val != val: # 先找到val的位置，然后跳出循环
            pre, cur = cur, cur.next
        if cur: # 考虑到，链表中不存在val这个值，这时候，cur会指向null，null没有next
            pre.next = cur.next
        return head

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

跟把0换到前面（后面）是一个道理
双指针，保证两个指针之间的都是偶数，奇数都在left之前，right后面是还没有判断的

class Solution:
    def exchange(self, nums: List[int]) -> List[int]:
        left, right = 0, 0
        while right < len(nums):
            if nums[right] % 2 ==1:
                nums[left], nums[right] = nums[right], nums[left]
                left += 1
            right += 1
        return nums

剑指 Offer 27. 二叉树的镜像

class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return root
        left = self.mirrorTree(root.left)
        right = self.mirrorTree(root.right)
        root.left, root.right = right, left
        return root

剑指 Offer 28. 对称的二叉树

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        def mirrortree(l,r):
            if not l and not r:
                return True
            if not l or not r or l.val != r.val:
                return False
            return mirrortree(l.left, r.right) and mirrortree(l.right, r.left)
        if root:
            return mirrortree(root.left, root.right)
        else:
            return True

剑指 Offer 30. 包含min函数的栈

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.a = []
        self.b = []


    def push(self, x: int) -> None:
        self.a.append(x) # a存的是按顺序输入的元素
        if not self.b or self.b[-1] >= x: # b栈顶存的是当前最小值
            self.b.append(x)


    def pop(self) -> None:
        if self.a.pop() == self.b[-1]: # 正常pop就是a.pop()就行，这里还要看，a弹出的是不是刚好是最小值，如果是，说明这个元素也在b中，需要弹出b才行
            return self.b.pop()


    def top(self) -> int:
        return self.a[-1]


    def min(self) -> int:
        return self.b[-1]

剑指 Offer 39. 数组中出现次数超过一半的数字

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        nums.sort()
        return nums[len(nums)//2]

剑指 Offer 50. 第一个只出现一次的字符

用字典建一个哈希表。字典无序，所以按照s的顺序查第一个符合条件的字符就行。

class Solution:
    def firstUniqChar(self, s: str) -> str:
        d = dict()
        for char in s:
            if char in d:
                d[char] += 1
            else: d[char]=1
        for i in s:
            if d[i]==1:
                return i
        return ' '