二分查找练习

二分查找/排序

BM17 二分查找-I

1、请实现无重复数字的升序数组的二分查找
给定一个 元素升序的、无重复数字的整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标（下标从 0 开始），否则返回 -1
数据范围：0 ≤len(nums)≤2×10^5， 数组中任意值满足:∣val∣≤10^9
进阶：时间复杂度 O(logn) ，空间复杂度 O(1)

示例1
输入：[-1,0,3,4,6,10,13,14],13
返回值：6
说明：13 出现在nums中并且下标为 6   
  
示例2
输入：[],3
返回值：-1
说明：nums为空，返回-1    
 
示例3
输入：[-1,0,3,4,6,10,13,14],2
返回值：-1
说明：2 不存在nums中因此返回 -1 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param nums int整型一维数组 
# @param target int整型 
# @return int整型
#
class Solution:
    def search(self , nums: List[int], target: int) -> int:
        # write code here
        # 方式一
        result = self.func_one(nums, target)
        # 方式二
        result = self.func_two(nums, target)
        # 方式三
        result = self.func_three(nums, target, 0, len(nums)-1)
        return result
        
    def func_one(self , nums: List[int], target: int) -> int:
        """in 的方式"""
        target_index = -1
        if nums !=[] and target in nums:
            target_index = nums.index(target)
            return target_index
        else:
            return target_index

    def func_two(self , nums: List[int], target: int) -> int:
        """迭代的方式"""
        start = 0
        end = len(nums) - 1
        middle = 0
        while start <= end:
            middle = (start + end) // 2
            if target == nums[middle]:
                return middle
            elif target < nums[middle]:
                end = middle - 1
            else:
                start = middle + 1
        return -1
    
    def func_three(self , nums: List[int], target: int, start:int, end:int) -> int:
        """递归方式"""
        if start > end :
            return -1
        
        mid = (start + end) // 2
        if nums[mid] > target:
            return self.func_three(nums, target, start, mid-1)
        elif nums[mid] < target:
            return self.func_three(nums, target, mid+1, end)
        else:
            return mid
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

BM18 二维数组中的查找

描述
在一个二维数组array中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
[
[1,2,8,9],
[2,4,9,12],
[4,7,10,13],
[6,8,11,15]
]
给定 target = 7，返回 true。
给定 target = 3，返回 false。
数据范围：矩阵的长宽满足 5000≤n,m≤500 ， 矩阵中的值满足10^90≤val≤10
9
进阶：空间复杂度 O(1)，时间复杂度 O(n+m)

示例1
输入：7,[[1,2,8,9],[2,4,9,12],[4,7,10,13],[6,8,11,15]]
返回值：true
说明：存在7，返回true    
 
示例2
输入：1,[[2]]
返回值：false

示例3
输入：3,[[1,2,8,9],[2,4,9,12],[4,7,10,13],[6,8,11,15]]
返回值：false
说明：不存在3，返回false   
1
2
3
4
5
6
7
8
9
10
11
12
13

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param target int整型 
# @param array int整型二维数组 
# @return bool布尔型
#
class Solution:
    def Find(self , target: int, array: List[List[int]]) -> bool:
        # write code here
        # 方式一:直接遍历使用in判断
        result = False
        for a in array:
            if target in a:
                return True
        # 方式二：通过二分法迭代查找
        result = False
        for a in array:
            result = self.func(a, target)
            if result:
                return True
        return result
    
        # 方式三：杨氏矩阵查找法，从左下角开始
        result = self.func_two(target, array)
        return result
    
    def func(self, nums: list, target:int) -> bool:
        """迭代"""
        start = 0
        end = len(nums) -1
        while start <= end:
            mid = (start + end) // 2
            if target == nums[mid]:
                return True
            elif target > nums[mid]:
                start = mid + 1
            else:
                end = mid -1
        return False
    
    def func_two(self, target: int, array: List[List[int]]) -> bool:
        """杨氏矩阵查找"""
        len_m = len(array)
        len_n = len(array[0])
        i = len_m - 1
        j = 0
        while i >= 0 and j <= len_n - 1:
            if target == array[i][j]:
                return True
            elif target > array[i][j]:
                j += 1
            else:
                i -= 1
        return False
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

BM19 寻找峰值

描述
给定一个长度为n的数组nums，请你找到峰值并返回其索引。数组可能包含多个峰值，在这种情况下，返回任何一个所在位置即可。
1.峰值元素是指其值严格大于左右相邻值的元素。严格大于即不能有等于
2.假设 nums[-1] = nums[n] = -\infty−∞
3.对于所有有效的 i 都有 nums[i] != nums[i + 1]
4.你可以使用O(logN)的时间复杂度实现此问题吗？
数据范围：1≤nums.length≤2×10 ^5
-2^{31}<= nums[i] <= 2^{31} - 1
如输入[2,4,1,2,7,8,4]时，会形成两个山峰，一个是索引为1，峰值为4的山峰，另一个是索引为5，峰值为8的山峰

示例1
输入：[2,4,1,2,7,8,4]
返回值：1
说明：4和8都是峰值元素，返回4的索引1或者8的索引5都可以 
1
2
3
4

示例2
输入：[1,2,3,1]
返回值：2
说明：3 是峰值元素，返回其索引 2   
1
2
3
4

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param nums int整型一维数组 
# @return int整型
#
class Solution:
    def findPeakElement(self , nums: List[int]) -> int:
        # write code here
        # 方式一
        max_data = max(nums)
        if len(nums) == 1:
            return 0
        if nums[0] != max_data or nums[-1] != max_data:
            max_index = nums.index(max_data)
            return max_index
         # 方式二
         result = self.func(nums)
         return result
        
    def func(self , nums: List[int]):
        if len(nums) == 1:
            return 0
        if nums[0] > nums[1]:
            return 0
        if nums[len(nums)-1] > nums[len(nums)-2]:
            return len(nums) - 1
        for i in range(1, len(nums)-1):
            if nums[i] > nums[i-1] and nums[i] > nums[i+1]:
                return i
        return 0                                           
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

BM21 旋转数组的最小数字

描述
有一个长度为 n 的非降序数组，比如[1,2,3,4,5]，将它进行旋转，即把一个数组最开始的若干个元素搬到数组的末尾，变成一个旋转数组，比如变成了[3,4,5,1,2]，或者[4,5,1,2,3]这样的。请问，给定这样一个旋转数组，求数组中的最小值。
数据范围：100001≤n≤10000，数组中任意元素的值: 100000≤val≤10000
要求：空间复杂度：O(1) ，时间复杂度：O(logn)

示例1
输入：[3,4,5,1,2]
返回值：1

示例2
输入：[3,100,200,3]
返回值：3
1
2
3
4
5
6
7

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param rotateArray int整型一维数组 
# @return int整型
#
class Solution:
    def minNumberInRotateArray(self , rotateArray: List[int]) -> int:
        # write code here
        # 方式一
        min_data = min(rotateArray)
        return min_data
        # 方式二
        if len(rotateArray) == 0:
            return 0
        left = 0
        right = len(rotateArray) -1
        while left < right:
            if rotateArray[left] < rotateArray[right]:
                return rotateArray[left]
            mid = (left + right) //2
            if rotateArray[mid] > rotateArray[right]:
                left = mid + 1
            elif rotateArray[mid] < rotateArray[right]:
                right = mid
            else:
                right -= 1
        return rotateArray[left]
        
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

BM22 比较版本号

描述
牛客项目发布项目版本时会有版本号，比如1.02.11，2.14.4等等
现在给你2个版本号version1和version2，请你比较他们的大小
版本号是由修订号组成，修订号与修订号之间由一个".“连接。1个修订号可能有多位数字组成，修订号可能包含前导0，且是合法的。例如，1.02.11，0.1，0.2都是合法的版本号
每个版本号至少包含1个修订号。
修订号从左到右编号，下标从0开始，最左边的修订号下标为0，下一个修订号下标为1，以此类推。
比较规则：
一. 比较版本号时，请按从左到右的顺序依次比较它们的修订号。比较修订号时，只需比较忽略任何前导零后的整数值。比如"0.1"和"0.01"的版本号是相等的
二. 如果版本号没有指定某个下标处的修订号，则该修订号视为0。例如，“1.1"的版本号小于"1.1.1”。因为"1.1"的版本号相当于"1.1.0”，第3位修订号的下标为0，小于1
三. version1 > version2 返回1，如果 version1 < version2 返回-1，不然返回0.
数据范围：10001<=version1.length,version2.length<=1000
version1 和 version2 的修订号不会超过int的表达范围，即不超过 32 位整数 的范围
进阶： 时间复杂度 O(n)

示例1
输入："1.1","2.1"
返回值：-1
说明：version1 中下标为 0 的修订号是 "1"，version2 中下标为 0 的修订号是 "2" 。1 < 2，所以 version1 < version2，返回-1
           
示例2
输入："1.1","1.01"
返回值：0
说明：version2忽略前导0，为"1.1"，和version相同，返回0 
          
示例3
输入："1.1","1.1.1"
返回值：-1
说明："1.1"的版本号小于"1.1.1"。因为"1.1"的版本号相当于"1.1.0"，第3位修订号的下标为0，小于1，所以version1 < version2，返回-1    
       
示例4
输入："2.0.1","2"
返回值：1
说明：version1的下标2>version2的下标2，返回1    
       
示例5
输入："0.226","0.36"
返回值：1
说明：226>36，version1的下标2>version2的下标2，返回1       
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 比较版本号
# @param version1 string字符串 
# @param version2 string字符串 
# @return int整型
#
class Solution:
    def compare(self , version1: str, version2: str) -> int:
        # write code here
        # 切割字符串
        v1_list = version1.split('.')
        v2_list = version2.split('.')
        len_v1 = len(v1_list)
        len_v2 = len(v2_list)
        
        i = 0
        # 缺省的列表元素补0
        if len_v1 < len_v2:
            for l in range(len_v2-len_v1):
                v1_list.append('0')
        elif len_v1 > len_v2:
            for l in range(len_v1-len_v2):
                v2_list.append('0')
        # 两个列表的下标为i的元素进行比较
        while i < len_v1:
            if int(v1_list[i]) > int(v2_list[i]):
                return 1
            elif int(v1_list[i]) < int(v2_list[i]):
                return -1
            else:
                i += 1
        return 0
            
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
34
35