算法第一天

704 二分查找

力扣链接： [704. 二分查找](704. 二分查找 - 力扣（LeetCode）)

【题目描述】

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

【示例】

示例1：

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例2：

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

【思路】

在题目中我们可以注意到在本题中的数组是一个有序数组，同时数组中的所有元素是不重复的，重复的元素往往会导致在返回时获得的下标不唯一。因此在满足以上条件时，我们才可能要考虑使用二分法。

二分法是较为简单的算法，逻辑并不复杂，但是边界值的分析往往会出现问题。我的理解中将这类边界分为两类：左闭右闭、左闭右开。

左闭右闭

即在判断时能达到右边界left<=right，在定义时right=nums.Length-1，同时如果在下文中target<nums[middle]时，right=middle-1；

左闭右闭

在判断时无法达到右边界left<right，在定义时right=nums.Length，同时如果在下文中target<nums[middle]时，right=middle；

---

既然已经分析好思路了，上代码！

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

这是左闭右闭区间，由于数组有序递增，通过判断nums[middle]与target的大小，来选择向哪一边进行缩小。

但是我们通过提交后可以发现，这个执行的速度并不够快，这时我们可以观察到middle的赋值那里有一个/2操作，经过多年计算机专业知识的熏陶（不是）我们可以想到一个更加高效的方法——位运算！直接上代码

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

哎，这个逻辑上好像没有问题了，但是一提交发现时间超限，这是为什么呢？

通过对运算符优先级的了解，我们发现>>运算符的优先级很低，因此我们只需要加上一个（）就可以咯

代码如下

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

轻松（）拿下这道入门二分法！

---

27 移除元素

力扣链接：[27.移除元素](27. 移除元素 - 力扣（LeetCode）)

【题目描述】

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

【示例】

示例1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例2：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

【思路】

由于数组在内存中的存储地址是连续的，因此我们无法直接将元素从数组中删除，只能选择将后面的元素向前移动并覆盖。在本题中，我想到了两种解决方案，第一个是暴力循环，第二个是双指针。

暴力法

第一个外层for循环用于遍历每个数组元素，当某个元素与需要删除的值相等时，进入内层循环，在内层循环中将当前下标的下一位元素全部前移一位。这个方法简单暴力，但是时间复杂度达到了o(n²)，在数据量很大的时候往往会出现超时的情况。

双指针

双指针的思考角度就是快慢指针，程序开始时两个指针同时向后移动，当nums[fast]!=val时，快慢指针同时向后移动，当nums[fast]==val时，慢指针在本次循环中停止移动，从而达到数组元素前移的目的。

【代码】

暴力法

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

在以上代码中可以注意到，我们需要获取数组的初始长度，因为在后续代码运行中可能会让他发生动态变化。

其次在每一次if判断中，都要进行size--,i--操作，因为我们在数组元素前移时数组的长度就会减1，同时外层循环的变量i也需要减1。

双指针

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

双指针的思想在上面已经提过了，这里就不再重复了。

---

总结

重新把以前抛弃的算法捡起来，还有点熟悉的感觉，多多努力！