萱仔求职系列——3.1_力扣面试150题目——数组&字符串第一弹

萱仔求职系列 评论

由于最近求职又涉及到很多面试时候敲代码，我又不得不捡起我的老力扣，只能说刷题这个东西必须越耍越上瘾，我将稳定更新，每天做3-10题

面试经典 150 题 - 学习计划 - 力扣（LeetCode）全球极客挚爱的技术成长平台

-------------------------------------------------------------------------------------------------------

88. 合并两个有序数组

给你两个按
非递减顺序
排列的整数数组
nums1

和
nums2
，另有两个整数
m
和
n
，分别表示
nums1
和
nums2
中的元素数目。

请你
合并
nums2

到
nums1
中，使合并后的数组同样按
非递减顺序
排列。

注意：
最终，合并后数组不应由函数返回，而是存储在数组
nums1
中。为了应对这种情况，
nums1
的初始长度为
m + n
，其中前
m
个元素表示应合并的元素，后
n
个元素为
0
，应忽略。
nums2
的长度为
n
。

这个题目吧，非常简单，要把n2合到n1里，不能重新搞一个新的表出来，由于它本身就是两个非递减的整数数组，我直接用3个指针就好啦，重点在于我要从后往前里面填入数据，因为他那个从前往后会盖住后面的数，没有空位。

对比两个蓝色的，然后大的往绿色那填，就这么easy~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        # 初始化指针
        n1 = m - 1  # nums1 的有效部分的最后一个元素
        n2 = n - 1  # nums2 的最后一个元素
        j = m + n - 1  # 合并后数组的最后一个位置
        for i in range(m + n):
            if n2 < 0:#没有可以合并的啦
                break
            elif n1 >= 0 and nums1[n1] > nums2[n2]:
                nums1[j] = nums1[n1]
                n1=n1-1
            else:
                nums1[j] = nums2[n2]
                n2=n2-1
            j=j-1

27. 移除元素

给你一个数组
nums

和一个值
val
，你需要
原地
移除所有数值等于
val

的元素。元素的顺序可能发生改变。然后返回
nums
中与
val
不同的元素的数量。

假设
nums
中不等于
val
的元素数量为
k
，要通过此题，您需要执行以下操作：

  • 更改
    nums
    数组，使
    nums
    的前
    k
    个元素包含不等于
    val
    的元素。
    nums
    的其余元素和
    nums
    的大小并不重要。
  • 返回
    k
    。

这个有一个题解写的很好，简单来说就是把所有不等于val的填到nums里

1
2
3
4
5
6
7
8
9
10

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        k=0
        for i in range(0,len(nums)):
            if nums[i]!=val:
                nums[k]=nums[i]
                k=k+1
                #print(k)
        return k

26. 删除有序数组中的重复项

这个题我用字典记录出现过的数字，然后遍历即可

1
2
3
4
5
6
7
8
9
10
11
12
13

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        dic = {}  
        k = 0  # 个数
        
        for i in range(len(nums)):
            if nums[i] not in dic:
                dic[nums[i]] = True  # 记录该元素已经出现过
                nums[k] = nums[i]  # 将非重复元素放在前面
                k += 1  # 计数+1

        return k

80. 删除有序数组中的重复项 II

给你一个有序数组
nums
，请你
原地
删除重复出现的元素，使得出现次数超过两次的元素
只出现两次
，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在
原地
修改输入数组
并在使用 O(1) 额外空间的条件下完成。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        # 如果数组长度小于等于 2，直接返回长度
        if len(nums) <= 2:
            return len(nums)
        # k 指向要插入的下一个位置
        k = 2
        # 从索引 2 开始遍历数组
        for i in range(2, len(nums)):
            # 只要当前元素与 k-2 位置的元素不相同，说明没有超过两次
            if nums[i] != nums[k - 2]:
                nums[k] = nums[i]
                k += 1
        return k

169. 多数元素

给定一个大小为
n

的数组
nums
，返回其中的多数元素。多数元素是指在数组中出现次数
大于
⌊ n/2 ⌋
的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

接着用字典解决熬，记住每个词出现的次数，我这个解法虽然很拉，但是个人认为思路简单，无脑解决问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        dic={}
        k=0
        for i in range(0,len(nums)):
            if nums[i] not in dic:
                dic[nums[i]]=1 
            elif nums[i]  in dic:
                dic[nums[i]]=1+dic[nums[i]] #每个数字出现的次数，遇见了就加一个
        for key, value in dic.items():
            if value>(len(nums)//2) :
                print(key,value)
                k=key #输出符合要求的key
        return k

189. 轮转数组

给定一个整数数组
nums
，将数组中的元素向右轮转
k

个位置，其中
k

是非负数。

真的很无语以下是一个使用了切片的错误代码，求有没有大佬可以帮看一下这个错误的为什么不对，明明print是对的。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        n=len(nums)
        n1=nums[0:k+1]
        n2=nums[k+1:n]
        nums2=n2
        for i in range(0,len(n1)):
            nums2.append(n1[i])
            print(nums2)
        return nums2

这是结果：

萱仔萱仔的自我学习记录，冲冲冲！

个人简介