2023-05-16:给你一个 严格升序排列 的正整数数组 arr 和一个整数 k 。 请你找到这个数组里第 k 个缺失的正整数。 输入:arr = [2,3,4,7,11], k = 5。 输出:9

2023-05-16:给你一个 严格升序排列 的正整数数组 arr 和一个整数 k 。

请你找到这个数组里第 k 个缺失的正整数。

输入:arr = [2,3,4,7,11], k = 5。

输出:9。

答案2023-05-16:

大体步骤如下:

1.初始化左指针l为0,右指针r为数组长度减一,定义中间指针m和find(找到第k个正整数前的下标位置),并将find初始化为数组长度。

2.当左指针小于等于右指针时,执行二分查找。令m等于左指针和右指针之间的中间值。(注:这里取中间值可以使用位运算优化)。

3.如果当前位置arr[m]减去(m+1)大于等于k,说明第k个缺失的正整数在当前位置左侧,更新find为当前位置m,并把右指针r设为m-1,继续二分查找左半部分。

4.如果当前位置arr[m]减去(m+1)小于k,说明第k个缺失的正整数在当前位置右侧,把左指针l设为m+1,继续二分查找右半部分。

5.查找结束后,如果find等于0,说明要找的是第一个缺失的正整数,返回0即可;否则,找到第k个正整数前的一个位置,把这个位置上的元素赋值给preValue,计算从当前位置到第k个正整数的缺失数量under,最终结果就是preValue加上k减去under的值。

6.返回结果。

时间复杂度为O(logn),其中n是数组的长度。因为代码采用了二分查找的算法,每次查找可以将搜索范围缩小一半,所以时间复杂度为O(logn)。

空间复杂度为O(1),因为代码只使用了常数个变量来存储中间结果,与输入数据的规模大小无关。因此,空间复杂度为常数级别。

go完整代码如下:

package main

import "fmt"

func findKthPositive(arr []int, k int) int {
	l := 0
	r := len(arr) - 1
	m := 0
	find := len(arr)
	for l <= r {
		m = (l + r) / 2
		if arr[m]-(m+1) >= k {
			find = m
			r = m - 1
		} else {
			l = m + 1
		}
	}
	preValue := 0
	if find == 0 {
		preValue = 0
	} else {
		preValue = arr[find-1]
	}
	under := preValue - find
	return preValue + (k - under)
}

func main() {
	arr := []int{2, 3, 4, 7, 11}
	k := 5
	result := findKthPositive(arr, k)
	fmt.Println(result)
}

在这里插入图片描述

rust完整代码如下:

fn find_kth_positive(arr: Vec<i32>, k: i32) -> i32 {
    let mut l = 0;
    let mut r = arr.len() - 1;
    let mut m = 0;
    let mut find = arr.len();
    while l <= r {
        m = (l + r) / 2;
        if arr[m] - (m as i32 + 1) >= k {
            find = m;
            r = m - 1;
        } else {
            l = m + 1;
        }
    }
    let pre_value = if find == 0 { 0 } else { arr[find - 1] };
    let under = pre_value - (find as i32);
    return pre_value + (k - under);
}

fn main() {
    let arr: Vec<i32> = vec![2, 3, 4, 7, 11];
    let k: i32 = 5;
    let result = find_kth_positive(arr, k);
    println!("{}", result);
}

在这里插入图片描述

c语言完整代码如下:

#include <stdio.h>

int findKthPositive(int* arr, int arrSize, int k) {
    int l = 0;
    int r = arrSize - 1;
    int m = 0;
    int find = arrSize;
    while (l <= r) {
        m = (l + r) / 2;
        if (arr[m] - (m + 1) >= k) {
            find = m;
            r = m - 1;
        }
        else {
            l = m + 1;
        }
    }
    int preValue = find == 0 ? 0 : arr[find - 1];
    int under = preValue - find;
    return preValue + (k - under);
}

int main() {
    int arr[] = { 2, 3, 4, 7, 11 };
    int k = 5;
    int arrSize = sizeof(arr) / sizeof(arr[0]);
    int result = findKthPositive(arr, arrSize, k);
    printf("%d\n", result);
}

在这里插入图片描述

c++完整代码如下:

#include <iostream>
#include <vector>

using namespace std;

int findKthPositive(vector<int>& arr, int k) {
    int l = 0;
    int r = arr.size() - 1;
    int m = 0;
    int find = arr.size();
    while (l <= r) {
        m = (l + r) / 2;
        if (arr[m] - (m + 1) >= k) {
            find = m;
            r = m - 1;
        }
        else {
            l = m + 1;
        }
    }
    int preValue = find == 0 ? 0 : arr[find - 1];
    int under = preValue - find;
    return preValue + (k - under);
}

int main() {
    vector<int> arr = { 2, 3, 4, 7, 11 };
    int k = 5;
    int result = findKthPositive(arr, k);
    cout << result << endl;
}

在这里插入图片描述

posted @ 2023-05-16 21:14  福大大架构师每日一题  阅读(38)  评论(0编辑  收藏  举报