代码随想录算法训练营第一天|704.二分查找、27.移除元素

代码随想录算法训练营第一天|704.二分查找、27.移除元素

数组预备知识

数组知识文章链接：数组知识点

704.二分查找

题目链接：704.二分查找

文章讲解：文章讲解

视频讲解：视频讲解

思路：

• 二分查找就是分治思想的体现，把一个主问题划分为几个更小的子问题，然后求解子问题，合并子问题的答案，最后就是主问题的答案。
• 这道题按照区间来考虑的话，可以分为左闭右闭区间，左闭右开区间。我们看待区间时，要注意区间的边界值可不可以取，这直接影响到我们代码边界值的取值问题，一定要细心。

适用条件：

• 数组是按照升序排序的。
• 数组中没有重复元素。

左闭右闭区间情况

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

时间复杂度：O(logn)
空间复杂度：O(1)

左闭右开区间情况

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

时间复杂度：O(logn)
空间复杂度：O(1)

27.移除元素

题目链接：27.移除元素

文章讲解：文章讲解

视频讲解：视频讲解

思路：

• 暴力搜索法： 暴力搜索法就是运用两个循环进行解题。外循环负责遍历所有的元素，找到和目标值相等的元素，内循环负责的是元素的移动，找到与目标值相等的元素后，对后面的元素一个个向前移动来覆盖这个相等的元素。
• 快慢指针法： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
  • 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组。
  • 慢指针：指向更新 新数组下标的位置。

• 相向双指针法： 定义两个指针，一个指针从左边开始遍历，一个指针从右边开始遍历，left指针负责找到与val相等的元素下标，right指针负责找到与val不相等的元素下标，如何用右边元素覆盖左边元素。按照上述步骤不停循环，直到左指针和右指针相遇。

暴力解法

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

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

快慢指针法

class Solution {
    public int removeElement(int[] nums, int val) {
        // 快慢指针
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.length; fastIndex++) {
            if (nums[fastIndex] != val) {
                nums[slowIndex] = nums[fastIndex];
                slowIndex++;
            }
        }
        return slowIndex;
    }
}

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

相向双指针法

//写法一：
class Solution {
    public int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length;
        while (left < right) {
            if (nums[left] == val) {
                nums[left] = nums[right - 1];
                right--;
            } else {
                left++;
            }
        }
        return left;
    }
}
//写法二：
class Solution {
    public int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length - 1;
        while(right >= 0 && nums[right] == val) right--; //将right移到从右数第一个值不为val的位置
        while(left <= right) {
            if(nums[left] == val) { //left位置的元素需要移除
                //将right位置的元素移到left（覆盖），right位置移除
                nums[left] = nums[right];
                right--;
            }
            left++;
            while(right >= 0 && nums[right] == val) right--;
        }
        return left;
    }
}
 nums[right];
                right--;
            }
            left++;
            while(right >= 0 && nums[right] == val) right--;
        }
        return left;
    }
}
//写法三：
class Solution {
    public int removeElement(int[] nums, int val) {
        int left= 0;
        int right = nums.length - 1;
        while (left <= right) {  //这里什么时候取等号呢？
            // 找左边等于val的元素
            while (left <= right && nums[left] != val){
                ++left;
            }
            // 找右边不等于val的元素
            while (left <= right && nums[right] == val) {
                -- right;
            }
            // 将右边不等于val的元素覆盖左边等于val的元素
            if (left < right) {
                nums[left++] = nums[right--];
            }
        }
        return left;   // leftIndex一定指向了最终数组末尾的下一个元素
    }
};

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