Day01 | 704、 二分查找 && 27、移除元素

1、数组概念

数组是存放在连续内存空间上的相同类型数据的集合。

需要两点注意的是

• 数组下标都是从0开始的。
• 数组内存空间的地址是连续的。
• 数组的元素不能删除，只能覆盖。

2、题目

704、二分查找

二分查找算法仅适用于有序序列

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

class Solution {
    public int search(int[] nums, int target) {
        // 1、判断目标值是否在数组中，不在直接返回-1
        while (target > nums[nums.length - 1] || target < nums[0]) {
            return -1;
        }
        // 2、定义两个变量，分别赋值，区间左闭右闭[0，nums.length-1]
        int left = 0, right = nums.length - 1;
        // 3、判断是否完成一轮查询
        while(left <= right) {
            // 4、定义mid并赋值，以下写法效果同 int mid = (left + right) / 2
            int mid = left + ((right - left) >> 1);
            // 5、查找存在目标值直接返回下标
            if(nums[mid] == target) {
                return mid;                 
            }else if(nums[mid] < target) {  // 如果nums[mid]小于目标值，将mid + 1 赋值给left
                left = mid + 1;
            }else if(nums[mid] > target) {  // 如果nums[mid]大于目标值，将mid - 1 赋值给right
                right = mid - 1;
            }
        }
        // 6、未查找到目标值，返回-1
        return -1;
    }
}

• 循环条件： left <= right
• 中间位置计算： mid = left + ((right -left) >> 1)
• 左边界更新：left = mid + 1
• 右边界更新： right = mid - 1
• 返回值： mid / -1

1、循环条件中包含了 left == right的情况，所以必须在每次循环中改变 left 和 right的指向，以防止进入死循环
2、循环终止的条件包括：

• 找到了目标值
• left > right （这种情况发生于当left, mid, right指向同一个数时，这个数还不是目标值，则整个查找结束。）

3、left + ((right -left) >> 1) 其实和 (left + right) / 2是等价的，这样写的目的一个是为了防止 (left + right)出现溢出，一个是用右移操作替代除法提升性能。
4、left + ((right -left) >> 1) 对于目标区域长度为奇数而言，是处于正中间的，对于长度为偶数而言，是中间偏左的。因此左右边界相遇时，只会是以下两种情况：

• left/mid , right (left, mid 指向同一个数，right指向它的下一个数)
• left/mid/right （left, mid, right 指向同一个数）

即因为mid对于长度为偶数的区间总是偏左的，所以当区间长度小于等于2时，mid 总是和 left在同一侧。

27、移除元素

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

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

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

示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。

示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

你不需要考虑数组中超出新长度后面的元素。

指针在C或者C++中存在，在java中不存在
指针：数据的内存地址 ，指针变量是用来存放内存地址的变量

解法一：暴力遍历

//解法一:暴力遍历

class Solution {
    public int removeElement(int[] nums, int val) {
        int size = nums.length;
        // 1、第一层for循环遍历数组元素
        for (int i = 0; i < size; i++) {
            if (nums[i] == val) { 	// 发现需要移除的元素，就将数组集体向前移动一位
                // 2、第二层for循环更新数组
                for (int j = i + 1; j < size; j++) {
                    nums[j - 1] = nums[j];		//在java中赋值
                }
                i--; 				// 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                size--; 			// 此时数组的大小减去一
            }
        }
        return size;				// 返回数组长度
    }
}

时间复杂度：O(n^2)
空间复杂度：O(1)

解法二：双指针

双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

定义快慢指针

• 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
• 慢指针：指向更新 新数组下标的位置

双指针法（快慢指针法）常见于数组和链表的操作中

//一、快慢指针法
// java中不存在指针，这里只是一个位置记录，可以作为指针理解
class Solution {
    public int removeElement(int[] nums, int val) {
        // 1、定义慢指针
        int slowIndex = 0;
        // 2、循环中定义快指针，并使用快指针遍历
        for (int fastIndex = 0; fastIndex < nums.length; fastIndex++) {
        	// 3、判断是否存在目标元素，不存在，将快指针赋值给慢指针，且慢指针下标移动
            if (nums[fastIndex] != val) {
                nums[slowIndex] = nums[fastIndex];
                slowIndex++;
            }
        }
        // 4、返回最后的慢指针，即为去掉目标值后数组的长度
        return slowIndex;
    }
}

//二、相向双指针法 
class Solution {
    public int removeElement(int[] nums, int val) {
    	// 1、定义左指针left并赋值为0，定义右指针right为数组长度减一
        int left = 0;
        int right = nums.length - 1;
        // 2、right指向从右数第一个值非目标值的位置
        while(right >= 0 && nums[right] == val) right--; 
        // 3、左右指针未重合时，从left位置开始判断数组元素是否需要移除
        while(left <= right) {
            if(nums[left] == val) { 
            	// 需要移除，将right位置的元素移到left（覆盖），并将right左移一位（即为right--）
                nums[left] = nums[right];
                right--;
            }
            // 不需要移除，将left右移（即为left++）,右指针位置为第一个非目标值
            left++;
            while(right >= 0 && nums[right] == val) right--;
        }
        // 4、返回left即为数组长度
        return left;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)
以上两种方法中的快慢指针法未改变移除元素后的相对位置，相向双指针法改变了元素相对位置，确保了移动最少元素