力扣面试150题-合并两个有序数组和移除元素

day1

合并两个有序数组（简单）

题目描述

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
进阶：你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗？

示例

示例 1：
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

示例 2：
输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。

示例 3：
输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

个人想法

最简单的做法，粗暴的将两个数组拼成一个数组，再使用Arrays.sort()进行排序;

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
       int i,j;
       j=0;
       if(n!=0){
            for(i=m;i<m+n;i++){
                nums1[i]=nums2[j];
                j++;
            }
        }
       Arrays.sort(nums1);
    }
}

问题：空间复杂度和时间复杂度双高
进阶想法：考虑到两个数组都是递减数组，创建一个m长度的数组num3，将num1中的值放在num3，可以采取依次从头开始依次比较num2，num3，将较小的元素插入到num1中，知道某一个数组插入完毕，将另外一个数组全部插入num1.

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
      int[]nums3=new int[m];
      int i,j,k;
      for(i=0;i<m;i++){
        nums3[i]=nums1[i];//将num1转移到num3中
      }
      i=j=k=0;//i为num3的索引，j为nums2的索引,k为num3的索引
      while(i!=m&&j!=n){
        if(nums3[i]<nums2[j]){//nums2和nums3中较小的插入nums1
            nums1[k]=nums3[i];
            i++;
            k++;
        }
        else{
            nums1[k]=nums2[j];
            j++;
            k++;
        }
      }
      //循环退出 说明一个数组已经插入结束 直接将另一数组剩下的插入即可
      if(i==m){
        for(j=j;j<n;j++){
            nums1[k]=nums2[j];
            k++;
        }
        }
        else{
           for(i=i;i<m;i++){
            nums1[k]=nums3[i];
            k++;
        } 
        }
      }
}

问题：空间复杂度高了，并且还需要进行nums1到nums3的转移，额外消耗了时间复杂度
最终做法：考虑从后向前进行比较，将较大的元素插入到num1的后面。

class Solution {
   public void merge(int[] nums1, int m, int[] nums2, int n) {
       int k = m + n - 1;
       int i=m-1;
       int j=n-1;
       while (i >= 0 && j >= 0) {
           if (nums1[i] > nums2[j]) {
               nums1[k] = nums1[i];
               k--;
               i--;
           } else {
               nums1[k] = nums2[j];
               k--;
               j--;
           }
       }
         while (j >= 0) {
            nums1[k] = nums2[j];
            k--;
            j--;
        }
   }
}

移除元素（简单）

题目描述

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
返回 k。
用户评测：

评测机将使用以下代码测试您的解决方案：

int[] nums = […]; // 输入数组
int val = …; // 要移除的值
int[] expectedNums = […]; // 长度正确的预期答案。
// 它以不等于 val 的值排序。

int k = removeElement(nums, val); // 调用你的实现

assert k == expectedNums.length;
sort(nums, 0, k); // 排序 nums 的前 k 个元素
for (int i = 0; i < actualLength; i++) {
assert nums[i] == expectedNums[i];
}
如果所有的断言都通过，你的解决方案将会 通过。

示例

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2,,]
解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。
示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3,,,_]
解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。
注意这五个元素可以任意顺序返回。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

个人想法

从头开始查看每个元素，
如果这个元素值为val，则从他向后检索找到第一个非val的值，交换它们两个的值，sum++，
如果这个元素不为val，则直接sum++即可，
结束条件有两种
1.检查完所有元素后自动结束
2 如果查看到一个val的元素，向后检索到最后一个还是val，说明其后全为val，则可以直接返回

class Solution {
    public int removeElement(int[] nums, int val) {
        int sum=0;
        int i=0;
        int j=1;
        for(i=i;i<nums.length;i++){//依次检查每个元素
            if(nums[i]!=val){//不等于val值 则返回值++
                sum++;
            }
            else{//若当前为val值则判断下一个是否为val
               if(i+1>=nums.length){//没有下一个直接结束
                break;
               }
               else{
                for(j=i+1;j<nums.length;j++){//从为val值找到第一个不是val的值
                    if(nums[j]!=val){//若前移的元素不是val 则向前移动到检索到为val值的元素这里
                        nums[i]=nums[j];
                        nums[j]=val;
                        sum++;
                        break;
                    }
                }
                if(j==nums.length-1&&nums[j]==val){
                    //若检查到了最后一个元素发现还是val说明所有为val的值都移动到了数组最后几位了
                    return sum;
                }
               }
            }
        }
        return sum;
}}