代码随想录算法学习Day1| LeetCode704 二分查找、LeetCode27 移除元素、LeetCode34 在排序数组中查找元素的第一个和最后一个位置、LeetCode35 搜索插入位置-CSDN博客

本文链接：https://blog.csdn.net/lubbour/article/details/141106161

数组理论基础欠缺（语言：C#）

二维数组在内存的空间地址是连续的
二维数组的声明
二维数组的使用
- arr.GetLength(0)获得行，arr.GetLength(1)获得列

数组的数组的声明

int[][] arr = new int[n][];
for (int k = 0; k < n; k++)
    arr[k] = new int[n];

704.二分查找

1、之前背过，能比较熟练地写出来（左闭右闭）

public class Solution
{
    public int Search(int[] nums, int target)
    {
        int left = 0;
        int right = nums.Length - 1;
        while (left <= right)
        {
            int mid = (left + right) / 2;
            if (target < nums[mid])
            {
                right = mid - 1;
            }
            else if (target > nums[mid])
            {
                left = mid + 1;
            }
            else
            {
                return mid;
            }
        }

        return -1;
    }
}

2、补充左闭右开

public class Solution
{
    public int Search(int[] nums, int target)
    {
        int left = 0;
        int right = nums.Length;
        while (left < right)
        {
            int mid = (left + right) / 2;
            if (target < nums[mid])
            {
                right = mid;
            }
            else if (target > nums[mid])
            {
                left = mid + 1;
            }
            else
            {
                return mid;
            }
        }

        return -1;
    }
}

27.移除元素

没看解题思路前：遍历数组，找到与val不同的元素，记录个数resultCount并将该元素放置在数组中当前resultCount-1的索引位置（相当于在遍历过程中一边记录一边覆盖）

public class Solution
{
    public int RemoveElement(int[] nums, int val)
    {
        int resultCount = 0;
        for (int i = 0; i < nums.Length; i++)
        {
            if (nums[i] != val)
            {
                resultCount++;
                nums[resultCount - 1] = nums[i];
            }
        }

        return resultCount;
    }
}

看完解题思路后：运用快慢指针法，通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

快指针：遍历数组元素，寻找新数组的元素（就是不与目标元素相等的元素）
慢指针：指向更新新数组下标的位置

public class Solution
{
    public int RemoveElement(int[] nums, int val)
    {
        int slow = 0;
        for (int fast = 0; fast < nums.Length; fast++)
        {
            if (nums[fast] != val)
            {
                nums[slow++] = nums[fast];
            }
        }

        return slow;
    }
}

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

没看解题思路前：遍历数组，把与目标相等的元素的索引位置记录在新数组中

public class Solution
{
    public int[] SearchRange(int[] nums, int target)
    {
        int[] result = new[] { -1, -1 };
        for (int fast = 0; fast < nums.Length; fast++)
        {
            if (nums[fast] == target)
            {
                if (result[0] == -1)
                {
                    result[0] = fast;
                }
                else
                {
                    result[1] = fast;
                }
            }
        }

        if (result[0] != -1 && result[1] == -1)
        {
            result[1] = result[0];
        }

        return result;
    }
}

看完解题思路后：运用二分法，分别寻找左边界（元素第一个出现的位置）和右边界（元素最后一个出现的位置）

左边界：保证该元素的左边没有与目标相同的元素，如果有，缩小右边界
右边界：保证该元素的右边没有与目标相同的元素，如果有，缩小左边界

这题可以先把数组中无重复元素的二分法先写出来，再去考虑有重复元素的情况（这时只要调整target == nums[mid]里的情况）

public class Solution
{
    public int[] SearchRange(int[] nums, int target)
    {
        int firstPos = SearchFirstPos(nums, target);
        int lastPos = SearchLastPos(nums, target);
        return new int[]{firstPos, lastPos};
    }

    public int SearchFirstPos(int[] nums, int target)
    {   
        int left = 0;
        int right = nums.Length - 1;
        while (left <= right)
        {
            int mid = (left + right) / 2;
            if (target < nums[mid])
            {
                right = mid - 1;
            }
            else if (target > nums[mid])
            {
                left = mid + 1;
            }
            else
            {
                //前面没有与目标值相同的元素时直接返回
                if (mid == 0 || nums[mid-1] < target)
                {
                    return mid;
                }
                else //否则缩小右边界
                {
                    right = mid - 1;
                }
            }
        }

        return -1;
    }

    public int SearchLastPos(int[] nums, int target)
    {
        int left = 0;
        int right = nums.Length - 1;
        while (left <= right)
        {
            int mid = (left + right) / 2;
            if (target < nums[mid])
            {
                right = mid - 1;
            }
            else if (target > nums[mid])
            {
                left = mid + 1;
            }
            else
            {
                //后面没有与目标值相同的元素时直接返回
                if (mid == nums.Length-1 || nums[mid+1] > target)
                {
                    return mid;
                }
                else //否则缩小左边界
                {
                    left = mid + 1;
                }
            }
        }

        return -1;
    }
}

反思：题目没看清，以为数组是无序的，所以没有想到用二分法而是直接暴力解决

这里划重点：二分法的前提是数组为有序数组，以后只要看到面试题里给出的数组是有序数组，都可以想一想是否可以使用二分法

35.搜索插入位置

没看解题思路前：先实现二分查找，最后调整return -1时的情况（循环结束后分为三种：left为mid时、right为mid时、left和right都不为mid时）

public class Solution
{
    public int SearchInsert(int[] nums, int target)
    {
        int left = 0;
        int right = nums.Length - 1;
        int mid = 0;
        while (left <= right)
        {
            mid = (left + right) / 2;
            if (target < nums[mid])
            {
                right = mid - 1;
            }
            else if (target > nums[mid])
            {
                left = mid + 1;
            }
            else
            {
                return mid;
            }
        }

        if (mid == left)
        {
            return target > nums[mid] ? mid + 1 : mid;
        }
        else if (mid == right)
        {
            return target > nums[mid] ? mid + 1 : mid;
        }
        else
        {
            return target > nums[mid] ? mid + 1 : mid - 1;
        }
    
    }
}

看了解题思路后：如图是左闭右闭情况下

需要考虑的情况有四种：

target在数组所有元素之前 [0, -1]， return right + 1
target等于数组中某一个元素 return middle;
target插入数组中的位置 [left, right]，return right + 1
target在数组所有元素之后的情况 [left, right]，因为是右闭区间，所以 return right + 1

因此可以合并成return right+1

public class Solution
{
    public int SearchInsert(int[] nums, int target)
    {
        int left = 0;
        int right = nums.Length - 1;
        while (left <= right)
        {
            int mid = (left + right) / 2;
            if (target < nums[mid])
            {
                right = mid - 1;
            }
            else if (target > nums[mid])
            {
                left = mid + 1;
            }
            else
            {
                return mid;
            }
        }

        return right + 1;
    }
}

PS：看了解题思路后再看我自己的思路简直两眼一黑。。。看来还是得多理解下当target不在数组中时left和right的变化

当target不在数组中，循环结束时（即 left > right），left 最终会指向第一个大于 target 的元素的位置或数组末尾的下一个位置，right 则指向最后一个小于target 的元素的位置