Leetcode 剑指2 easy

Rocket,Qian

已于 2022-06-22 19:31:01 修改

阅读量99

点赞数

分类专栏： ---数据结构与算法--- # 剑指offer 文章标签： leetcode 剑指offer2

于 2022-06-15 15:53:50 首次发布

本文链接：https://blog.csdn.net/weixin_44127327/article/details/125295227

版权

---数据结构与算法--- 同时被 2 个专栏收录

55 篇文章 0 订阅

订阅专栏

剑指offer

3 篇文章 0 订阅

订阅专栏

Leetcode 剑指2 easy汇总

间隔好久没做题了，再次刷吧！菜啊！！！

1. 剑指 Offer 03. 数组中重复的数字

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

class Solution:
    def findRepeatNumber(self, nums: List[int]) -> int:
        hash_ = dict()
        for i in nums:
            if i not in hash_:
                hash_.setdefault(i,1)
            else:
                hash_[i] += 1
            if hash_[i] > 1:
                break
        return i

2. 剑指 Offer 05. 替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

class Solution:
    def replaceSpace(self, s: str) -> str:
        lst = s.split(' ')
        return "%20".join(lst)

3. 剑指 Offer 06. 从尾到头打印链表

从尾到头打印链表
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        lst = []
        while head:
            lst.append(head.val)
            head = head.next
        return lst[::-1]

4. 剑指 Offer 09. 用两个栈实现队列

链接
用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

class CQueue:
    def __init__(self):
        self.stack1 = []
        self.stack2 = []

    def appendTail(self, value: int) -> None:
        self.stack1.append(value)
        
    def deleteHead(self) -> int:
        if self.stack2:
            return self.stack2.pop()
        else:
            while self.stack1:
                self.stack2.append(self.stack1.pop())
            return self.stack2.pop() if self.stack2 else -1

# Your CQueue object will be instantiated and called as such:
# obj = CQueue()
# obj.appendTail(value)
# param_2 = obj.deleteHead()

5. 剑指 Offer 10- I. 斐波那契数列

链接
写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。

class Solution:
    def fib(self, n: int) -> int:
        a = 0
        b = 1

        for _ in range(n):
            a,b = b,a + b
        return a % 1000000007

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

链接
一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

class Solution:
    def numWays(self, n: int) -> int:
        a = 1
        b = 1
        for _ in range(n):
            a,b = b ,a +b
        return a % 1000000007

7. 剑指 Offer 11. 旋转数组的最小数字

链接
给你一个可能存在重复元素值的数组 numbers ，它原来是一个升序排列的数组，并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一次旋转，该数组的最小值为 1。

class Solution:
    def minArray(self, numbers: List[int]) -> int:
        return sorted(numbers)[0]

二分查找

class Solution:
    def minArray(self, numbers: List[int]) -> int:
        i , j = 0,len(numbers) - 1
        while i < j:
            m = (i + j) // 2  
            if numbers[m] > numbers[j]:
                i = m + 1
            elif numbers[m] < numbers[j]:
                j = m
            else:
                j -= 1
        return numbers[i]

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

链接
编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量).）。

class Solution:
    def hammingWeight(self, n: int) -> int:
        ans = 0
        while n:
            ans += n & 1
            n >>=1
        return ans

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

链接
输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。

未考虑大数越界情况

class Solution:
    def printNumbers(self, n: int) -> List[int]:
        ans = []
        for i in range(1,10**n):
            ans.append(i)
        return ans

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

链接
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。返回删除后的链表的头节点。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def deleteNode(self, head: ListNode, val: int) -> ListNode:
        if head.val == val:
            return head.next
        pre , cur = head, head.next
        while cur and cur.val != val:
            pre ,cur = cur, cur.next
        if cur: pre.next = cur.next
        return head

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

链接
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数在数组的前半部分，所有偶数在数组的后半部分。
双指针

class Solution:
    def exchange(self, nums: List[int]) -> List[int]:
        i , j = 0 ,len(nums)-1
        while i < j:
            while i < j and nums[i] & 1 == 1: i += 1
            while i < j and nums[j] & 1 == 0: j -= 1
            nums[i], nums[j] = nums[j], nums[i]
        return nums

12. 剑指 Offer 22. 链表中倒数第k个节点

链接
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
        former , latter = head ,head
        for _ in range(k):
            former = former.next
        while former:
            former = former.next
            latter = latter.next
        return latter

------2022.06.15-------

13. 剑指 Offer 24. 反转链表 *

链接
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        cur , pre = head , None
        while cur:
            tmp = cur.next  # 暂存后继节点 cur.next
            cur.next = pre  # 修改 next 引用指向
            pre = cur      # pre 暂存 cur
            cur = tmp
        return pre

递归

在这里插入代码片

14. 剑指 Offer 25. 合并两个排序的链表

链接
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        cur = tmp = ListNode(0)
        while l1 and l2:
            if l1.val < l2.val:
                cur.next = l1
                l1 = l1.next
            else:
                cur.next = l2
                l2 = l2.next
            cur = cur.next
        cur.next = l1 if l1 else l2
        return tmp.next

15. 剑指 Offer 27. 二叉树的镜像

链接
请完成一个函数，输入一个二叉树，该函数输出它的镜像。

16. 剑指 Offer 28. 对称的二叉树

链接
请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

17. 剑指 Offer 29. 顺时针打印矩阵

链接
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

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

链接
定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

class MinStack:

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

    def push(self, x: int) -> None:
        self.stack1.append(x)
        if not self.stack2 or self.stack2[-1] >= x:
            self.stack2.append(x)

    def pop(self) -> None:
        if self.stack1.pop() == self.stack2[-1]:
            self.stack2.pop()

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

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


# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(x)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.min()

19. 剑指 Offer 32 - II. 从上到下打印二叉树 II

链接
从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

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

链接
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。

# 字典计数
# 摩尔消元
class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        tmp = 0
        for num in nums:
            if tmp == 0: ans = num
            if ans == num:
                tmp +=1
            else:
                tmp -=1
        return ans