代码随想录leetcode刷题Day02-移除元素（部分）

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

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

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

 */

//先双层for循环遍历：
class Solution {
    public int removeElement(int[] nums, int val) {
        int len = nums.length;
        for (int i = 0; i < len; i++) {
            if (nums[i] == val) {//找到了对应的元素
                for (int j = i; j < len - 1; j++) {
                    nums[j] = nums[j + 1];//把该元素自己及后面的元素向前移动一位
                }
                len--;//每找到一个相同的（进行依次内层循环），数组长度要减少一个
                i--;//i也要减小，因为元素全部向前移动一位，下次外层循环还从这个位置开始
            }
        }
        return len;
    }
}

//改进：使用双指针法，进行一次遍历就可以
//快指针fast对数组进行遍历，每次取出不是val的元素（更新后数组的元素）
//慢指针slow只在找到新数组元素后+1，使得元素录入到新数组对应的位置
class Solution1 {
    public int removeElement(int[] nums, int val) {
        int slow = 0;
        for (int fast = 0; fast < nums.length; fast++) {
            if (nums[fast] != val) {
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }
}

//26. 删除有序数组中的重复项
/*
给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，
返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。
 */

//先双层for循环遍历
class Solution2 {
    public int removeDuplicates(int[] nums) {
        int len = nums.length;
        for (int i = 1; i < len; i++) { //对数组进行遍历
            if (nums[i] == nums[i - 1]) { //如果这个元素和前一个位置的元素相等
                // （注意防空指针，第一个元素不判断）
                for (int j = i; j < len - 1; j++) { //（从这个元素开始，每个后面元素向前移一位）
                    nums[j] = nums[j + 1];
                }
                i--;//注意把i也减少一个，下次还从这个位置开始判断
                len--;//原始长度减一，最终要返回假数组长度
            }
        }
        return len;
    }
}

//双指针法
class Solution3 {
    public int removeDuplicates(int[] nums) {
        int slow = 1;//经过分析，原数组0位置元素必被保留，因此慢指针从1位置开始
        for (int fast = 1; fast < nums.length; fast++) {
            if (nums[fast] != nums[fast - 1]) {
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }
}

//双指针另解
class Solution4 {
    public int removeDuplicates(int[] nums) {
        int slow = 0;//如果我还想让慢指针在0位置，也就是从0位置开始覆盖数组...
        for (int fast = 1; fast < nums.length; fast++) {
            if (nums[fast] != nums[slow]) { //如果快指针所在位置元素与慢指针所在位置元素不同
                slow++;//先移动
                nums[slow] = nums[fast];//再覆盖
            }
        }
        return ++slow; //注意返回的是slow + 1
    }
}

//283.移动零
/*
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
 */

//思路是，不移动0，移动其他元素到前面，最后补充0
//这样时间复杂度为O(n)，还不错
class Solution5 {
    public void moveZeroes(int[] nums) {
        int slow = 0;
        for (int fast = 0; fast < nums.length; fast++) {
            if (nums[fast] != 0) { //如果元素不是0
                nums[slow++] = nums[fast]; //把元素移动到数组前方，slow++
            }
        }
        for (int i = slow; i < nums.length; i++) { //最后补充0元素
            nums[i] = 0;
        }
    }
}

//也可以使用双指针
//快指针进行遍历，遇到不为0的元素，和慢指针处元素调换位置，之后慢指针向右移动
class Solution6 {
    public void moveZeroes(int[] nums) {
        int slow = 0;
        int temp;
        for (int fast = 0; fast < nums.length; fast++) {
            if (nums[fast] != 0) {
                temp = nums[fast];
                nums[fast] = nums[slow];
                nums[slow++] = temp;
            }
        }
    }
}

//977.有序数组的平方
/*
给你一个按 非递减顺序 排序的整数数组 nums，
返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
 */
class Solution7 {
    public int[] sortedSquares(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            nums[i] = nums[i] * nums[i];
        }
//        int temp;
//        boolean isFlag = false;
//        for(int i = 0;i < nums.length - 1;i++){
//
//            for(int j = 0;j < nums.length-i-1;j++){
//                if(nums[j] > nums[j + 1]){
//                    temp = nums[j];
//                    nums[j] = nums[j + 1];
//                    nums[j + 1] = temp;
//                    isFlag = true;
//                }
//            }
//            if(!isFlag){
//                break;
//            }
//        }
        Arrays.sort(nums);
        return nums;
    }
}

class Solution8 {
    public int[] sortedSquares(int[] nums) {
        //先更新num数组，计算元素平方
        for (int i = 0; i < nums.length; i++) {
            nums[i] = nums[i] * nums[i];
        }
        //注意到正数部分是递增，负数部分递减，因此最大值一定在两侧取到，之后依次向中间缩减即可
        //这里需要新创建一个数组
        int head = 0;
        int end = nums.length - 1;
        int[] arr = new int[nums.length];
        for (int i = arr.length - 1; i >= 0 && head <= end; i--) {
            if (nums[head] > nums[end]) {
                arr[i] = nums[head];
                head++;
            } else {
                arr[i] = nums[end];
                end--;
            }
        }
        return arr;
    }
}

//也可以合并在一起，一个循环搞定
class Solution9 {
    public int[] sortedSquares(int[] nums) {

        int head = 0;
        int end = nums.length - 1;
        int[] arr = new int[nums.length];
        for (int i = arr.length - 1; i >= 0; i--) {
            if (nums[head] * nums[head] > nums[end] * nums[end]) {
                arr[i] = nums[head] * nums[head];
                head++;
            } else {
                arr[i] = nums[end] * nums[end];
                end--;
            }
        }
        return arr;
    }
}