[Swift]LeetCode34. 在排序数组中查找元素的第一个和最后一个位置 | Find First and Last Position of Element in Sorted Array

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9900149.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given an array of integers nums sorted in ascending order, find the starting and ending position of a given target value.

Your algorithm's runtime complexity must be in the order of O(log n).

If the target is not found in the array, return [-1, -1].

Example 1:

Input: nums = [5,7,7,8,8,10], target = 8
Output: [3,4]

Example 2:

Input: nums = [5,7,7,8,8,10], target = 6
Output: [-1,-1]

---

给定一个按照升序排列的整数数组 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]

---

【二进制搜索】

直觉

因为数组已排序，我们可以使用二进制搜索来定位最左边和最右边的索引。

算法

除了用于查找最左侧和最右侧索引本身的子例程之外，整体算法与线性扫描方法的工作方式非常相似。在这里，我们使用修改后的二进制搜索来搜索已排序的数组，并进行一些小的调整。首先，因为我们正在找到最左边（或最右边）的索引target（而不是返回true我们找到的iff target），所以算法一找到匹配就不会终止。相反，我们继续搜索，直到lo == hi它们包含一些target可以找到的索引。

另一个变化是引入left参数，这是一个布尔值，表示在事件中要做什么target == nums[mid]; 如果 left是true，那么我们在关系上的左子阵列上“递归”。否则，我们走对了。要了解为什么这是正确的，请考虑我们target在索引处找到的情况 i。最左边target不能出现任何大于的索引i，因此我们永远不需要考虑正确的子阵列。相同的参数适用于最右边的索引。

下面的第一个动画显示了查找最左侧索引的过程，第二个动画显示了查找最右侧索引的索引右侧的过程。

68ms

class Solution {
    func searchRange(_ nums: [Int], _ target: Int) -> [Int] {
        var targetRange:[Int] = [-1, -1]
        var leftIdx:Int = extremeInsertionIndex(nums, target, true)
        
        // 声明`leftIdx` 在数组的边界内并且是 `target`
        // 实际上在`nums`中
        if leftIdx == nums.count || nums[leftIdx] != target
        {
            return targetRange
        }
        
        targetRange[0] = leftIdx
        targetRange[1] = extremeInsertionIndex(nums, target, false) - 1
        
        return targetRange
    }
    
    // 返回 `target`应该是最左边(或最右边)的索引
    // 通过二进制搜索插入排序数组'nums'.
    func extremeInsertionIndex(_ nums: [Int], _ target: Int,_ left:Bool) -> Int
    {
        var lo:Int = 0
        var hi:Int = nums.count
        
        while (lo < hi)
        {
            var mid:Int = (lo + hi) / 2
            if nums[mid] > target || (left && target == nums[mid])
            {
                hi = mid
            }
            else
            {
                lo = mid+1
            }
        }
        return lo
    }
}

---

12ms

class Solution {
    func searchRange(_ nums: [Int], _ target: Int) -> [Int] {
        let start = binarySearch(nums, target)

        if start == nums.count || nums[start] != target {
            return [-1, -1]
        }

        let end = binarySearch(nums, target + 1) - 1

        return [start, end]
    }

    private func binarySearch(_ nums: [Int], _ target: Int) -> Int {
        var left = 0
        var right = nums.count

        while left < right {
            let middle = left + (right - left) / 2
            if nums[middle] < target {
                left = middle + 1
            } else {
                right = middle
            }
        }

        return left
    }
}

---

16ms

class Solution {
    func searchRange(_ nums: [Int], _ target: Int) -> [Int] {
        var left = 0
    var right = nums.count - 1
    var mid = 0
    var first = -1
    
    // 寻找第一个出现target的位置
    while left <= right {
        mid = left + (right - left)/2
        if nums[mid] >= target {
            right = mid - 1
        } else {
            left = mid + 1
        }
        if nums[mid] == target {
            first = mid
        }
    }
    
    // 如果找不到第一个直接返回
    if first == -1 {
        return [first ,first]
    }
    
    // 寻找最后一个出现target的位置
    var last = -1
    left = first
    right = nums.count - 1
    while left <= right {
        mid = left + (right - left)/2
        if nums[mid] > target {
            right = mid - 1
        } else {
            left = mid + 1
        }
        if nums[mid] == target {
            last = mid
        }
    }
    return [first,last]
    }
}

---

16ms

class Solution {
    func searchRange(_ nums: [Int], _ target: Int) -> [Int] {
        
        if nums.count == 1
        {
            if nums[0] == target
            {
                return [0,0]
            }
            else{
                return [-1,-1]
            }
        }
        var index = binarySearch(nums,0,nums.count-1,target)
        print(index)
        if index == -1
        {
            return [-1,-1]
        }
        let midIndex = index
        var keepGoing = true
        var startIndex = midIndex
        while keepGoing
        {
            index -= 1
            if index  >= 0
            {
                if nums[index] == target
                {
                    print("here")
                    startIndex = index
                }
                else{
                    keepGoing = false
                }
            }else{
                keepGoing = false
            }
        }
        
          keepGoing = true
        var endIndex = midIndex
        while keepGoing
        {
            index += 1
            if index  < nums.count
            {
                if nums[index] == target
                {
                    print("here2")
                    endIndex = index
                }
                else{
                    keepGoing = false
                }
            }
            else{
                keepGoing = false
            }
        }
      
        return [startIndex,endIndex]
    }
    
    func binarySearch(_ nums:[Int],_ lo:Int,_ hi:Int,_ target:Int)->Int
    {
          if lo == hi
        {
            if nums[lo] == target
            {
                return lo
            }
            else{
                return -1
            }
        }
        if lo < hi
        {
            var mi = (lo+hi)/2
            
            if nums[mi] == target
            {
                return mi
            }
            else if target < nums[mi]
            {
                return binarySearch(nums,lo,mi-1,target)
            }
            else if target > nums[mi]
            {
                return binarySearch(nums,mi+1,hi,target)
            }
        }
        return -1
    }
}

---

76ms

class Solution {
    func searchRange(_ nums: [Int], _ target: Int) -> [Int] {
        var startIndex: Int?
        var endIndex: Int?
        
        for (index, num) in nums.enumerated() {
            if num == target {
                if startIndex == nil {
                    startIndex = index
                }
                
                endIndex = index
            }
        }
        
        if startIndex == nil {
            return [-1, -1]
        } else {
            return [startIndex!, endIndex!]
        }
    }
}

---

104ms

class Solution {
    func searchRange(_ nums: [Int], _ target: Int) -> [Int] {
        var min = -1
        var max = -1
        for i in 0..<nums.count {
            guard nums[i] == target else {
                continue
            }
            if min == -1 {
                min = i
            }
            max = i
        }
        return [min, max]
    }
}