代码随想录算法训练营D1|数组理论基础，704. 二分查找，27. 移除元素

目录

数组

704. 二分查找

27. 移除元素

---

数组

• 数组是存放在连续内存空间上的相同类型数据的集合。
• 数组下标都是从0开始的。
• 数组内存空间的地址是连续的，因此在删除或者增添元素的时候，就难免要移动其他元素的地址。
• 数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。

704. 二分查找

二分查找的使用前提条件：1.有序数组，2.数组中无重复元素

根据数组下标区间的定义（左闭右闭/左闭右开）来决定边界条件

public class BinarySearch {

    /**
     * 左闭右闭区间的二分查找
     *
     * @param nums   整型数组
     * @param target 目标值
     * @return 下标
     */
    public int leftClosedRightClosedInterval(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;

        // 避免多次循环运算
        if (target < nums[left] || target > nums[right]) {
            return -1;
        }

        int mid;
        while (left <= right) {
            mid = left + ((right - left) / 2);
            // 目标值在左区间，重新给右边界赋值
            if (nums[mid] > target) {
                right = mid - 1;
            } else if (nums[mid] == target) {
                // 找到目标值
                return mid;
            } else {
                // 目标值在右区间，重新给左边界赋值
                left = mid + 1;
            }
        }
        return -1;
    }

    /**
     * 左闭右开区间的二分查找
     * @param nums 整数数组
     * @param target 目标值
     * @return 下标
     */
    public int leftClosedRightOpenInterval(int[] nums,int target){
        int left = 0;
        int right = nums.length;

        // 因为是有序数组，可以排除掉不在区间内的target，避免进入循环
        if (target < nums[left] || target >= nums[right-1]) {
            return -1;
        }
        int mid;
        while (left < target) {
            mid = left + ((right-left)/2);
            if (nums[mid] > target){
                // target在左区间，重新赋值右边界
                right = mid;
            }else if (nums[mid] == target){
                return mid;
            }else {
                // target在右区间，重新赋值左边界
                left = mid + 1;
            }
        }
        return -1;
    }
}

27. 移除元素

        由于数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖这一特点，移除数组中的元素需使用暴力解法（双层for循环）或双指针法（快慢指针）。

        双指针在一个for循环下完成双层for循环的操作，快指针代表外层for循环，寻找组成新数组的元素，慢指针则代表新数组的下标。

        双指针法在数组和链表的操作中比较常见。

        两种方法的空间复杂度都为O(1)，暴力解法的时间复杂度为O(N^2)，双指针的时间复杂度为O(N)。

public class RemoveElement {

    /**
     * 暴力解法
     *
     * @param nums
     * @param val
     * @return size 移除val元素后数组的新长度
     */
    public int bruteMethod(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];
                }
                // 移除后，下标i以后的值都往前移了一位，因而i需要前移
                i--;
                // 移除后，数组长度-1（其实空间没变，只是无需考虑超出新长度后的元素了）
                size--;
            }
        }
        return size;
    }

    /**
     * 双指针法（快慢指针）
     * @param nums
     * @param val
     * @return
     */
    public int twoPointersMethod(int[] nums,int val){
        int slow = 0;

        // 遍历原数组
        for (int fast = 0; fast < nums.length; fast++) {
            // 找到不同的元素，相同的元素慢指针不动，快指针跳过
            if (val != nums[fast]){
                nums[slow] = nums[fast];
                slow++;
            }
        }
        // 此时慢指针下标=新数组长度
        return slow;
    }
}