1.2 移除数组 1.3 有序数组的平方

这次整理的是代码随想录的数组部分移除数组和有序数组的平方的题目，总共5道。

直接开始刷题

leetcode 27 移除数组

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：
1、更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
2、返回 k。

方法一：顺向思维

class Solution {
    public int removeElement(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];
                }
                size--; //因为数组向前移动一位所以循环的区间可以少一
                i--; // 因为该位置已经是下一个数了，这个数还未判断，想确保下一次循环还是该位置所以-1
            }
        }
        return size;
    }
}

方法二：逆向思维

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

leetcode26 删除有序数组中重复项

给你一个非严格递增排列 的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：
1、更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
2、返回 k 。

class Solution {
    public int removeDuplicates(int[] nums) {
         int j = 1;
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] != nums[i - 1]) {
                nums[j] = nums[i]; //双指针，一旦有不一样的将j指针指向该位置
                j++;
            }
        }
        return j;
	}
}
     

leetcode283 移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。

方法一：先将不是0的放好，后面空的位置置为0。

public void moveZeroes(int[] nums) {
        if (nums == null || nums.length == 0)
            return;
        int j = 0;
        for (int num : nums) {
            if (num != 0)
                nums[j++] = num;
        }
        while (j < nums.length) {
            nums[j++] = 0;
        }
    }

方法二：双指针，我的理解是i反正是一直往前移动，如果数组都没有0的情况是，每次交换是指针i和j在同样的位置交换；只有出现数组有0的情况下指针j它是不跟着指针i移动的，这时两两交换就是j指到0的位置和i指到不是0的位置进行交换。

public void moveZeroes(int[] nums) {
     if (nums == null || nums.length == 0)
            return;
        int j = 0;
        for (int i = 0; i < nums.length; i++) {
            if(nums[i]!=0){
                int temp = nums[i];
                nums[i] = nums[j];
                nums[j++] = temp;
            }
        }
    }

leetcode844 比较含退格的字符串

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。
注意：如果对空文本输入退格字符，文本继续为空。

class Solution {
   public boolean backspaceCompare(String S, String T) {
        return sb(S).equals(sb(T));
    }

    private String sb(String str) {
        StringBuilder sbr = new StringBuilder();
        for (char c : str.toCharArray()) {
            if (c != '#') {
                sbr.append(c);
            } else if (sbr.length() != 0) { //必须在else后就是在=='#'再判断字符串是否为空
                sbr.deleteCharAt(sbr.length() - 1);//退格就要删除字符串最后一个索引元素
            }
        }
        return sbr.toString();
    }
}

    public boolean backspaceCompare(String S, String T) {
        return stackSolution(S).equals(stackSolution(T));
    }
    
    private String stackSolution(String str) {
        Stack<Character> stack = new Stack<Character>(); //使用栈来解决
        
        for (char c : str.toCharArray()) {
		
            if (c != '#') {
                stack.push(c);
				
            } else if (!stack.isEmpty()) {
                stack.pop();
            }
        }
        return stack.toString();
    }

leetcode977 有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
方法一：使用java库函数

public int[] sortedSquares(int[] nums) {
        int size = nums.length;
        for (int i = 0; i < size; i++) {
            nums[i] = nums[i]*nums[i];
        }
        Arrays.sort(nums);
        return nums;
    }

方法二：双指针，长的像二分法，二分法可以理解为是双指针的加强版。

  public int[] sortedSquares(int[] nums) {
        int l = 0;
        int r = nums.length-1;
        int idx =nums.length-1;
        int[] result = new int[nums.length];
        while (l<=r){
            if(Math.abs(nums[l])>Math.abs(nums[r])){
               result[idx] = nums[l]*nums[l];
               l++;
            }else{
                result[idx] = nums[r]*nums[r];
                r--;
            }
            idx--;
        }
        return result;
    }

刷题结束！！！