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

---

一、题目

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

二、示例

三、代码

解法1、双指针 （没指针上，直接暴力求解）
但是很明显没有起到太多节省时间的作用，时间复杂度是O(n),因为有一个循环遍历。

public int[] SearchRange(int[] nums, int target)
        {
            int left = -1, right = -1;
            int n = nums.Length - 1;
            bool leftFind = false, rightFind = false;
            for (int i = 0; i < nums.Length; i++,n--)
            {
                if (nums[i] == target)
                {
                    if (!leftFind)
                    {
                        left = i;
                        leftFind = true;
                    }
                }
                if (nums[n] == target)
                {
                    if (!rightFind)
                    {
                        right = n;
                        rightFind = true;
                    }
                }
            }
            return new int[] { left, right };
        }

我尝试使用一个if判断来减少时间，但是无论从理论还是从实际来看都是不可能的。

if (leftFind && rightFind)
{
     break;
}

因为无论怎样加判断都改变不了一个for循环遍历的事实。

解法2、二分查找
看题目写的时间复杂度是O(log n) ，非递减顺序排列的整数数组，自然而然想到二分查找。
以下为参考全站第一的选手的代码

public int[] SearchRange(int[] nums, int target)
        {
            int start = SearchStart(nums, target);
            if (start < 0)
            {
                return new int[]{ -1,-1 };
            }
            int end = SearchEnd(nums, target);
            return new int[] { start, end };
        }

        public int SearchStart(int[] nums, int target)
        {
            int low = 0, high = nums.Length - 1;
            while (low < high)
            {
                int mid = (low + high) / 2;
                if (nums[mid] >= target)
                {
                    high = mid;
                }
                else
                    low = mid + 1;
            }
            if (low < nums.Length && nums[low] == target)
            {
                return low;
            }
            else
                return -1;
        }
        public int SearchEnd(int[] nums, int target)
        {
            int low = 0, high = nums.Length - 1;
            while (low < high)
            {
                int mid = low + (high - low + 1) / 2;
                if (nums[mid] <= target)
                {
                    low = mid;
                }
                else
                    high = mid - 1;
            }
            if (low < nums.Length && nums[low] == target)
            {
                return low;
            }
            else
                return -1;
        }

为大佬献上膝盖！
一个二分查找向下取，一个二分查找向上取。用了两次二分查找。
该说不说大佬挺牛

要找到第一个开始位置，找到第一个符合条件的，就要向下取整，向下找，知道找到符合条件的。
low = mid+1；
当nums[mid] < target
mid一定是小于存储target值的数的下标。
所以low= mid+1；这个数的下一个开始判断。
当nums[mid] >= target；
high = mid;
high存的就是满足条件的下标，
最终一定会找到low=high的情况，
判断符不符合条件，符不符合low < nums.Length && nums[low]。
用来判断有没有目标值，nums数组是不是空数组。
符合条件输出 初始位置，不符合条件则没找到，返回-1

找最后一个位置，向上取整

与上半部分正好相反，向上取整，找最后，等于目标值的数。
由于向上取整，所以mid 计算过程中需要加1，不然会陷入死循环。
mid = low + (high - low + 1) / 2。
其他原理和上边一样。

如果 low = mid；就一定要考虑向上取整的问题。mid = low + (high - low + 1) / 2。

public int[] SearchRange(int[] nums, int target)
        {
			if (nums.Length==0)
            {
                return new int[] { -1, -1 };
            }
            int startPosion = StartFind(nums, target);
            if (startPosion < 0)
            {
                return new int[] { -1, -1 };
            }
            int endPosion = EndFind(nums, target);
            return new int[] { startPosion, endPosion };
        }

        public int StartFind(int[] nums, int target)
        {
            int low = 0, high = nums.Length - 1;
            while (low < high)
            {
                int mid = (low + high) / 2;
                if (target > nums[mid])
                {
                    low = mid + 1;
                }
                else if (target == nums[mid])
                {
                    high = mid;
                }
                else
                    high = mid - 1;
            }
            //if (target == nums[low])
            //{
            //    return low;
            //}
            //else
            //    return -1;
            return target == nums[low] ? low : -1;
        }

        public int EndFind(int[] nums, int target)
        {
            int low = 0, high = nums.Length - 1;
            while (low < high)
            {
                int mid = low + (high - low + 1) / 2;
                if (target > nums[mid])
                {
                    low = mid + 1;
                }
                else if (target == nums[mid])
                {
                    low = mid;
                }
                else
                    high = mid - 1;
            }
            return low;
        }

这个是看了官方题解，结合那个大佬的，重新写的，牛的牛的，大佬真厉害！

解法3、暴力求解
官方那个暴力求解条件不好控，参考另一个题友，添加控制变量。

public int[] SearchRange(int[] nums, int target)
{
    int[] a = new int[2] { -1, -1 };
    if (nums.Length == 0)
    {
        return new int[] { -1, -1 };
    }
    if (nums.Length == 1 && nums[0] == target)
    {
        return new int[] { 0, 0 };
    }
    int j = 0;
    for (int i = 0; i < nums.Length; i++)
    {
        if (target == nums[i])
        {
            if (j >= 2)
            {
                a[1] = i;
            }
            else
            {
                a[j] = i;
            }
            j++;
        }
    }
    if (j == 1)
    {
        a[1] = a[0];
    }
    return a;
}

---

分析总结

最后总结就是很简单，膜拜大佬。
方法千千万，学到最重要。