刷题笔记(数组)-08

合并两个有序数组

题目地址：合并两个有序数组

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        // 双指针解法
        // 定义两个指针
        int p1=0,p2=0;
        // 定义临时变量赋值
        int temp;
        // 定义排序数组
        int[] sort=new int[m+n];
        while(p1<m|p2<n){
            // m0 直接赋值temp
            if(p1==m){
                temp=nums2[p2++];
            }
            else if(p2==n){
                temp=nums1[p1++];
            }else if(nums1[p1]<nums2[p2]){
                // p1这里先赋值再++
                temp=nums1[p1++];
            }else{
                temp=nums2[p2++];
            }
            // 控制排序数组的赋值操作
            sort[p1+p2-1]=temp;
        }
        for(int i=0;i!=m+n;i++){
            nums1[i]=sort[i];
        }
    }
}

复杂度分析

• 时间复杂度：O(m+n)O(m+n)。
  指针移动单调递增，最多移动 m+n 次，因此时间复杂度为 O(m+n)O(m+n)。

• 空间复杂度：O(m+n)O(m+n)。
  需要建立长度为 m+n 的中间数组sorted。

解法2

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

有效的字母异位词

题目地址： 有效的字母异位词

解法1

class Solution {
    public boolean isAnagram(String s, String t) {
        if(s.length()!=t.length()){
          return false;
        }
         char[] str1 = s.toCharArray();
        char[] str2 = t.toCharArray();
        Arrays.sort(str1);
        Arrays.sort(str2);
        return Arrays.equals(str1, str2);
    }
}

解法2

看到大佬的思路，顿时膜拜，这里记录下这种解法！

原文链接：把数组当做哈希表来用，很巧妙！

数组其实就是一个简单的哈希表，这题目中字符串只有小写字母，可以定义一个数组，来记录字符串s里字符出现的次数，定义多大的数组呢，26即可，因为有26个英文字母

上动图！判断下字符串s="aee",t="eae"

定义一个数组record用来记录字符串s中字符出现的字数

需要把字符映射到数组也就是哈希表索引下表上 因为字符a到字符Z的ASCll是26个连续的数值，所以字符a的下表为0，相应的字符z映射下表25再遍历字符串s的时候，只需要将s[i]-'a'所在的元素+1操作即可，并不需要记住字符a的ASCll,只要求出一个相对数值即可，这样就将字符串s中字符出现的次数，统计出来了。
那看一下如何检查字符串t中是否出现了这些字符，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值再做-1的操作。
那么最后检查一下，record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false。
最后如果record数组所有元素都为零0，说明字符串s和t是字母异位词，return true。

时间复杂度为O(n)，空间上因为定义是的一个常量大小的辅助数组，所以空间复杂度为O(1)

class Solution {
    public boolean isAnagram(String s, String t) {
         int[] record=new int[26];
        for (char c : s.toCharArray()) {
            record[c-'a']+=1;
        }
        for (char c : t.toCharArray()) {
            record[c-'a']-=1;
        }
        for (int i : record) {
            if (i!=0){
                return false;
            }
        }
        return true;
    }
}

语言描述很抽象，大家可以自己放进IDE自己DEBUG

两个数组的交集

题目地址：两个数组的交集

思路：

使用两个Set集合，利用特点来去除重复元素,将Set1中的元素添加到Set2中，最后转换为数组，返回即可！

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        //创建Set集合，目的是去除重复元素
         Set<Integer> set1 = new HashSet<Integer>();
        Set<Integer> set2 = new HashSet<Integer>();
        for (int num : nums1) {
            set1.add(num);
        }
        for (int num : nums2) {
            set2.add(num);
        }
        return getIntersection(set1, set2);
    }

    public static int[] getIntersection(Set<Integer> set1, Set<Integer> set2) {
        if (set1.size() > set2.size()) {
            return getIntersection(set2, set1);
        }
        // 将set1的元素添加到set2中
        HashSet<Integer> integerHashSet = new HashSet<Integer>();
        for (Integer item : set1) {
            if (set2.contains(item)) {
                integerHashSet.add(item);
            }
        }
        // 转换为数组，返回即可
        int[] intersection = new int[integerHashSet.size()];
        int index = 0;
        for (int num : integerHashSet) {
            intersection[index++] = num;
        }
        return intersection;
    }
}

复杂度分析

• 时间复杂度：O(m+n)O(m+n)，其中 mm 和 nn 分别是两个数组的长度。使用两个集合分别存储两个数组中的元素需要 O(m+n)O(m+n) 的时间，遍历较小的集合并判断元素是否在另一个集合中需要 O(min(m,n))O(min(m,n)) 的时间，因此总时间复杂度是 O(m+n)O(m+n)。

• 空间复杂度：O(m+n)O(m+n)，其中 mm 和 nn 分别是两个数组的长度。空间复杂度主要取决于两个集合。

两数之和

题目地址：两数之和

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) {
                    int[] res=new int[]{i, j};
                    return res;
                }
            }
        }
        return new int[0];
    }
}

复杂度分析

• 时间复杂度：O(N²)O(N ²)，其中 N 是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。

• 空间复杂度：O(1)O(1)。

代码均由力扣编译器，提交通过，描述编写不当地方还请大家评论区指出💪！