leetcode刷题记录之34

34、在排序数组中查找元素的第一个和最后一个位置

  给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
  你的算法时间复杂度必须是 O(log n) 级别。
  如果数组中不存在目标值，返回 [-1, -1]。
示例 1：

输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]

示例 2：

输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]

难度：中等  题目地址：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/

1、C语言代码：

//解法一：
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* searchRange(int* nums, int numsSize, int target, int* returnSize){
    int *result = (int *)malloc(sizeof(int) * 2);
    int i = 0,j = numsSize - 1;
    while(i<j){
        if(nums[i]==target&&nums[j]==target)
            break;
        if(nums[i]<target&&nums[j]>target){
            i++; j--;
        }
        if(nums[i]<target&&nums[j]==target)
            i++;
        if(nums[i]==target&&nums[j]>target)
            j--;
        if(nums[i]>target||nums[j]<target)
            break;
    }
    if((i==j&&nums[i]!=target)||(numsSize==0)||(nums[i]>target)||(nums[j]<target)){
        result[0] = -1;
        result[1] = -1;
        *returnSize = 2;
        return result;
    }
    else{
        result[0] = i;
        result[1] = j;
        *returnSize = 2;
        return result;
    }
}

//解法二
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
 int* searchRange(int* nums, int numsSize, int target, int* returnSize){
   int i ,j;
   int *res = (int*)malloc(sizeof(int)*2);
    *returnSize = 2;
    res[0] = res[1] = -1;
   if(numsSize == 0){
       return res;
   }
   for(i = 0;i < numsSize;i++){
       if(nums[i] == target){
           res[0] = i;
           break;
       }
   }
   for(j = numsSize - 1;j >= 0;j--){
       if(nums[j] == target){
           res[1] = j;
           break;
       }
   } 
    return res;
}

解释： 解法一利用双指针，综合考虑各种情况；解法二则2次遍历数组得出答案。

知识点回顾： 无。

2、Java代码：

class Solution {
    // returns leftmost (or rightmost) index at which `target` should be
    // inserted in sorted array `nums` via binary search.
    private int extremeInsertionIndex(int[] nums, int target, boolean left) {
        int lo = 0;
        int hi = nums.length;
        while (lo < hi) {
            int mid = (lo + hi) / 2;
            if (nums[mid] > target || (left && target == nums[mid])) {
                hi = mid;
            }
            else {
                lo = mid+1;
            }
        }
        return lo;
    }
    public int[] searchRange(int[] nums, int target) {
        int[] targetRange = {-1, -1};
        int leftIdx = extremeInsertionIndex(nums, target, true);
        // assert that `leftIdx` is within the array bounds and that `target`
        // is actually in `nums`.
        if (leftIdx == nums.length || nums[leftIdx] != target) {
            return targetRange;
        }
        targetRange[0] = leftIdx;
        targetRange[1] = extremeInsertionIndex(nums, target, false)-1;
        return targetRange;
    }
}

解释： 总体算法工作过程与线性扫描方法类似，除了找最左和最右下标的方法。这里我们仅仅做几个微小的调整，用这种修改过的二分查找方法去搜索这个排过序的数组。首先，为了找到最左边（或者最右边）包含 target 的下标（而不是找到的话就返回 true ），所以算法在我们找到一个 target 后不能马上停止。我们需要继续搜索，直到 lo == hi 且它们在某个 target 值处下标相同。
  另一个改变是 left 参数的引入，它是一个 boolean 类型的变量，指示我们在遇到 target == nums[mid] 时应该做什么。如果 left 为 true ，那么我们递归查询左区间，否则递归右区间。考虑如果我们在下标为 i 处遇到了 target ，最左边的 target 一定不会出现在下标大于 i 的位置，所以我们永远不需要考虑右子区间。当求最右下标时，道理同样适用。

知识点回顾： 无。

3、Python代码：

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        l = bisect.bisect_left(nums,target)
        r = bisect.bisect_right(nums,target)
        if l >= len(nums) or nums[l] != target:
            return [-1,-1]
        return [l,r-1]

解释： 利用Python的模块求解。

知识点回顾：
1、Python 有一个 bisect 模块，用于维护有序列表。bisect 模块实现了一个算法用于插入元素到有序列表。在一些情况下，这比反复排序列表或构造一个大的列表再排序的效率更高。Bisect 是二分法的意思，这里使用二分法来排序，它会将一个元素插入到一个有序列表的合适位置，这使得不需要每次调用 sort 的方式维护有序列表。
bisect.bisect_left(a,x, lo=0, hi=len(a))
查找在有序列表 a 中插入 x 的index。lo 和 hi 用于指定列表的区间，默认是使用整个列表。如果 x 已经存在，在其左边插入。返回值为 index。
bisect.bisect_right(a,x, lo=0, hi=len(a))
bisect.bisect(a, x,lo=0, hi=len(a))
这2个函数和 bisect_left 类似，但如果 x 已经存在，在其右边插入。
bisect.insort_left(a,x, lo=0, hi=len(a))
在有序列表 a 中插入 x。和 a.insert(bisect.bisect_left(a,x, lo, hi), x) 的效果相同。
bisect.insort_right(a,x, lo=0, hi=len(a))
bisect.insort(a, x,lo=0, hi=len(a))
和 insort_left 类似，但如果 x 已经存在，在其右边插入。
Bisect 模块提供的函数可以分两类： bisect* 只用于查找 index， 不进行实际的插入；而 insort* 则用于实际插入。

4、JavaScript代码：

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var searchRange = function(nums, target) {
    return [nums.indexOf(target), nums.lastIndexOf(target)]
};

解释： 利用JavaScript自带方法求解。

知识点回顾：
1、indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。
如果没有找到匹配的字符串则返回 -1。
注意： indexOf() 方法区分大小写。
语法：string.indexOf(searchvalue,start)
searchvalue：必需。规定需检索的字符串值。
start：可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 string Object.length - 1。如省略该参数，则将从字符串的首字符开始检索。
返回值：查找指定字符串第一次出现的位置，如果没找到匹配的字符串则返回 -1。
2、lastIndexOf() 方法可返回一个指定的字符串值最后出现的位置，如果指定第二个参数 start，则在一个字符串中的指定位置从后向前搜索。
注意： 该方法将从后向前检索字符串，但返回是从起始位置 (0) 开始计算子字符串最后出现的位置。 看它是否含有字符串。开始检索的位置在字符串的 start 处或字符串的结尾（没有指定 start 时）。
如果没有找到匹配字符串则返回 -1 。
注意：lastIndexOf() 方法是区分大小写的！
语法：string.lastIndexOf(searchvalue,start)
searchvalue：必需。规定需检索的字符串值。
start：可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的最后一个字符处开始检索。
返回值：查找的字符串最后出现的位置，如果没有找到匹配字符串则返回 -1。