代码随想录算法Day1|（数组part1）704.二分查找、27.移除元素、977.有序数组的平方

class Solution {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1; //注意区分length是Array的属性，length()是String的方法
        int mid;
        while(left <= right){
            mid = left + (right - left) / 2;
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid] < target){
                left = mid + 1;
            }else{
                right = mid - 1;
            }
        }
        return -1;
    }
}

27.移除元素（双指针法）

题目链接：https://leetcode.cn/problems/remove-element/

文章讲解：https://programmercarl.com/0027.%E7%A7%BB%E9%99%A4%E5%85%83%E7%B4%A0.html

解题分析

除暴力方法外，数组无序，可考虑双指针法

本题代码

暴力法：

两层for循环，一个for循环遍历数组元素，第二个for循环更新数组

时间复杂度：O(n^2)
空间复杂度：O(1）
// 暴力法
class Solution {
    public int removeElement(int[] nums, int val) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            if (nums[i] == val) { // 发现需要移除的元素，就将数组集体向前移动一位
                for (int j = i + 1; j < n; j++) {
                    nums[j - 1] = nums[j];
                }
                i--; // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                n--; // 此时数组的大小-1
            }
        }
        return n;
    }
}

双指针法：

定义快慢指针

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

时间复杂度：O(n)
空间复杂度：O(1)
//相向双指针法
class Solution {
    public int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            if(nums[left] == val){
                nums[left] = nums[right];
                right--;
            }else if(nums[left] != val){
                left++;
            }
        }
        return left;
    }
}

977.有序数组的平方（双指针法）

题目链接：https://leetcode.cn/problems/squares-of-a-sorted-array/

文章讲解：https://programmercarl.com/0977.%E6%9C%89%E5%BA%8F%E6%95%B0%E7%BB%84%E7%9A%84%E5%B9%B3%E6%96%B9.html

解题分析

除暴力排序法外，还可考虑双指针法

本题代码

暴力排序：

//暴力排序：每个数平方之后，排个序
class Solution {
    public int[] sortedSquares(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            nums[i] = nums[i] * nums[i];
        }
        Arrays.sort(nums);
        return nums;
    }
}

双指针法：

因为数组升序，负数平方之后可能成为最大数，所以数组平方的最大值就在数组的两端，不是最左边就是最右边。

此时可以考虑双指针法了，i指向起始位置，j指向终止位置。

定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。

原数组两端i处和j处的数进行比较，大的那个数放进新数组k位置，k左移；然后原数组i处数大i右移，j处数大j左移，保持两端向中间移动的规律，直到遍历完整个数组，可得到有序新数组。

如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j];

如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i];

//双指针法
class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] Array = new int[nums.length];
        int l = 0;
        int r = nums.length - 1;
        int index = Array.length - 1;
        while(l <= r){
            if(nums[l] * nums[l] <= nums[r] *nums[r]){
                Array[index--] = (nums[r] *nums[r]);
                r--;
            }else{
                Array[index--] = (nums[l] * nums[l]);
                l++;
            }
        }
        return Array;
    }
}