算法 2.2.2 数组的相对排序【leetcode 1122】

题目描述

给你两个数组,arr1 和 arr2,
arr2 中的元素各不相同
arr2 中的每个元素都出现在 arr1 中

对 arr1 中的元素进行排序,使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。
未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。

示例:
输入:arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
输出:[2,2,2,1,4,3,3,9,6,7,19]

提示:
arr1.length, arr2.length <= 1000
0 <= arr1[i], arr2[i] <= 1000
arr2 中的元素 arr2[i] 各不相同
arr2 中的每个元素 arr2[i] 都出现在 arr1 中

数据结构

  • 数组

算法思维

  • 遍历、快速排序、计数排序

解题要点

  • 使用自定义的比较器应用于快速排序中
  • 使用计数排序,用空间换时间

解题思路


一. Comprehend 理解题意
  • arr1 中会存在重复数据,所以不能直接将 arr2 作为 arr1 的开始部分
  • 目标是将 arr1 中的元素排序,arr2 其实是作为排序依据

二. Choose 选择数据结构与算法
自定义比较器 + 快速排序
  • 数据结构:数组
  • 算法思维:遍历、递归、快速排序
解题思路
  • 需要设计一个排序算法,两个值A、B的排序规则为:
    如果 A、B 都出现在 arr2 中,则根据索引顺序比大小
    如果一个在 arr2 中,一个不在 arr2 中,则出现的元素排前面
    如果 A、B 都不在 arr2 中,则根据 A、B 的数值大小确定顺序

三. Code 编码实现基本解法
class Solution {
    public int[] relativeSortArray(int[] arr1, int[] arr2) {
        Map map = new HashMap<>();
        for (int i = 0; i < arr2.length; i++) {
            map.put(arr2[i], i); //注意:这里写成 map.put(i, arr2[i]) 是不可以的
        }
        quickSort(arr1, 0, arr1.length - 1, map);
        return arr1;
    }

    public void quickSort(int[] target, int low, int high, Map by) {
        int i = low;
        int j = high;
        //基准
        int datum = target[i];
        while (i < j) {
            while (i < j && compare(target[j], datum, by) >= 0) j--;
            if (i < j) target[i++] = target[j];
            while (i < j && compare(target[i], datum, by) <= 0) i++;
            if (i < j) target[j--] = target[i];
        }
        target[i] = datum; //放回基准值
        if (low < i - 1) quickSort(target, low, i - 1, by); //处理左子区
        if (high > i + 1) quickSort(target, i + 1, high, by); //处理右子区
    }

    public int compare(int a, int b, Map map) {
        int o1Index = map.getOrDefault(a, -1);
        int o2Index = map.getOrDefault(b, -1);
        if (o1Index == -1 && o2Index == -1) {
            return a - b;
        } else if (o1Index == -1) {
            return 1;
        } else if (o2Index == -1) {
            return -1;
        } else {
            return o1Index - o2Index;
        }
    }
}

执行耗时:3 ms,击败了 47.25% 的Java用户
内存消耗:38.9 MB,击败了 5.15% 的Java用户

时间复杂度:O(nlogn)
  • 一次快速排序 O(nlogn)
  • map 集合赋值 O(n)

空间复杂度:O(n)
  • n 层递归的内存空间 O(n)
  • map 集合的内存空间 O(n)

四. Consider 思考更优解
改变算法思维:计数排序,以空间换时间
  • 因为 arr[i] 为 0-1000,所以开辟一个长1001的数组 nums 用于记录各个数字出现的次数
  • 先遍历 arr1,记录各个数字出现的次数
  • 再遍历 arr2,对 arr2 中的每个数字按照 nums 中记录的次数依次在新数组 results 中存放
    同时 nums 中针对该数字的次数记录 -1
  • 遍历 nums 数组,对于次数不为0的,依次按照次数存放到 results 中
  • 返回 results 数组

五. Code 编码实现最优解
class Solution {
    public int[] relativeSortArray(int[] arr1, int[] arr2) {
        int[] nums = new int[1001];
        for (int i = 0; i < arr1.length; i++) {
            nums[arr1[i]]++;
        }
        int[] results = new int[arr1.length];
        int index = 0;
        for (int i = 0; i < arr2.length; i++) {
            while (nums[arr2[i]] != 0) {
                results[index++] = arr2[i];
                nums[arr2[i]]--;
            }
        }
        for (int i = 0; i < nums.length; i++) {
            while (nums[i] != 0) {
                results[index++] = i;
                nums[i]--;
            }
        }
        return results;
    }
}

执行耗时:0 ms,击败了 100.00% 的Java用户
内存消耗:38.3 MB,击败了 83.57% 的Java用户

时间复杂度:O(n)
  • 三次数组遍历 O(n)

空间复杂度:O(n)
  • 记录数字出现个数的数组的内存空间 O(n)
  • 结果数组的内存空间 O(n)

六. Change 变形与延伸

=== 待续 ===

你可能感兴趣的:(算法 2.2.2 数组的相对排序【leetcode 1122】)