【算法】二分查找-20231122

一、1089. 复写零

提示
简单
266
相关企业
给你一个长度固定的整数数组 arr ，请你将该数组中出现的每个零都复写一遍，并将其余的元素向右平移。

注意：请不要在超过该数组长度的位置写入元素。请对输入的数组 就地 进行上述修改，不要从函数返回任何东西。

示例 1：

输入：arr = [1,0,2,3,0,4,5,0]
输出：[1,0,0,2,3,0,0,4]
解释：调用函数后，输入的数组将被修改为：[1,0,0,2,3,0,0,4]
示例 2：

输入：arr = [1,2,3]
输出：[1,2,3]
解释：调用函数后，输入的数组将被修改为：[1,2,3]

class Solution:

    def duplicateZeros(self,arr):
        j=len(arr)-1
        i=0
        while i<j:
            if arr[i] == 0:
                arr.pop(j)
                arr.insert(i,0)
                i+=1
            i+=1
        return arr

ss=Solution()
arr=[1,0,2,3,0,4,5,0]
print(ss.duplicateZeros(arr))

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

二、917. 仅仅反转字母

提示
简单

给你一个字符串 s ，根据下述规则反转字符串：

所有非英文字母保留在原有位置。
所有英文字母（小写或大写）位置反转。
返回反转后的 s 。

示例 1：

输入：s = “ab-cd”
输出：“dc-ba”
示例 2：

输入：s = “a-bC-dEf-ghIj”
输出：“j-Ih-gfE-dCba”
示例 3：

输入：s = “Test1ng-Leet=code-Q!”
输出：“Qedo1ct-eeLg=ntse-T!”

思路
把字符串变成列表方便替换
设置指针 left, right == 0, len(s)
左指针小于右指针就循环处理
左右指针指定的都是字母交换位置， 左指针 +1 右指针 -1
左指针指定的不是字母 左指针 +1
右指针 指定的不是字母 右指针 -1
最后拼接字符串返回

作者：一不小心
链接：https://leetcode.cn/problems/reverse-only-letters/solutions/2496416/shuang-zhi-zhen-ji-zhi-ru-wo-by-yi-bu-xi-kg6v/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution:
    def reverseOnly(self,s):
        s=list(s)
        left=0
        right=len(s)-1
        while left<right:
            if s[left].isalpha() and s[right].isalpha():
                s[left],s[right]=s[right],s[left]
                left+=1
                right-=1
            elif not s[left].isalpha():
                left+=1
            elif not s[right].isalpha():
                right-=1
        return ''.join(s)
s = "a-bC-dEf-ghIj"
ss=Solution()
print(ss.reverseOnly(s))    ##j-Ih-gfE-dCba

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

三、88. 合并两个有序数组

提示
简单
2.2K
相关企业
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

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

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

示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
示例 2：

输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。
示例 3：

输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

class Solution:
    def merge(self, nums1, m, nums2, n):
        if n != 0:
            if m == 0:
                nums1[:] = nums2[:]
            else:
                p, q = 0, 0
                result = [0] * (m + n)
                for i in range(m + n):
                    if nums1[p] > nums2[q]:
                        result[i] = nums2[q]
                        q += 1
                    else:
                        result[i] = nums1[p]
                        p += 1
                    if p == m and q != n:
                        result[i + 1:] = nums2[q:]
                    elif p != m and q == n:
                        result[i + 1:] = nums1[p:m]
                    if p == m or q == n:
                        break

                nums1[:] = result[:]
        return nums1


s = Solution()

nums1 = [1, 2, 3, 0, 0, 0]
nums2 = [2, 5, 6]
res = s.merge(nums1, 3, nums2, 3)
print(res)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

四、283. 移动零

提示
简单
2.2K
相关企业
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
示例 2:

输入: nums = [0]
输出: [0]

def test3(nums):
    slow=0
    fast=0
    while fast<len(nums):
        if nums[fast]:
            nums[slow],nums[fast]=nums[fast],nums[slow]
            slow+=1
        fast+=1
    return nums

nums=[0]
print(test3(nums))
1
2
3
4
5
6
7
8
9
10
11
12