1122. 数组的相对排序

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

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

示例 1：

输入：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]
示例  2:

输入：arr1 = [28,6,22,8,44,17], arr2 = [22,28,8,6]
输出：[22,28,8,6,17,44]
 

提示：

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

方法一：自定义排序
一种容易想到的方法是使用排序并自定义比较函数。

由于数组 \textit{arr}_2arr 
2
​
  规定了比较顺序，因此我们可以使用哈希表对该顺序进行映射：即对于数组 \textit{arr}_2arr 
2
​
  中的第 ii 个元素，我们将 (\textit{arr}_2[i], i)(arr 
2
​
 [i],i) 这一键值对放入哈希表 \textit{rank}rank 中，就可以很方便地对数组 \textit{arr}_1arr 
1
​
  中的元素进行比较。

比较函数的写法有很多种，例如我们可以使用最基础的比较方法，对于元素 xx 和 yy：

如果 xx 和 yy 都出现在哈希表中，那么比较它们对应的值 \textit{rank}[x]rank[x] 和 \textit{rank}[y]rank[y]；

如果 xx 和 yy 都没有出现在哈希表中，那么比较它们本身；

对于剩余的情况，出现在哈希表中的那个元素较小。

class Solution {
public:
    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
        unordered_map<int, int> rank;
        for (int i = 0; i < arr2.size(); ++i) {
            rank[arr2[i]] = i;
        }
        sort(arr1.begin(), arr1.end(), [&](int x, int y) {
            if (rank.count(x)) {
                return rank.count(y) ? rank[x] < rank[y] : true;
            }
            else {
                return rank.count(y) ? false : x < y;
            }
        });
        return arr1;
    }
};

解法一
思路和算法
为了将数组 \textit{arr}_1arr 
1
​
  按照数组 \textit{arr}_2arr 
2
​
  的相对顺序排序，需要使用哈希表存储数组 \textit{arr}_2arr 
2
​
  中的每个元素与下标，然后将数组 \textit{arr}_1arr 
1
​
  中的元素分成两部分，在 \textit{arr}_2arr 
2
​
  中的元素是第一部分，不在 \textit{arr}_2arr 
2
​
  中的元素是第二部分，对两部分元素分别排序之后拼接，得到排序后的数组。

对于两部分排序的方法分别如下：

第一部分元素根据元素在哈希表中的下标决定排序顺序；

第二部分元素根据元素大小决定排序顺序。

当两部分元素都排序结束之后，创建与数组 \textit{arr}_1arr 
1
​
  等长的数组 \textit{sorted}sorted，依次遍历第一部分元素与第二部分元素并填入数组 \textit{sorted}sorted，则 \textit{sorted}sorted 即为排序后的数组。

class Solution {
    public int[] relativeSortArray(int[] arr1, int[] arr2) {
        Map<Integer, Integer> orderMap = new HashMap<Integer, Integer>();
        int length1 = arr1.length, length2 = arr2.length;
        for (int i = 0; i < length2; i++) {
            orderMap.put(arr2[i], i);
        }
        List<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();
        for (int i = 0; i < length1; i++) {
            int num = arr1[i];
            if (orderMap.containsKey(num)) {
                list1.add(num);
            } else {
                list2.add(num);
            }
        }
        Collections.sort(list1, (a, b) -> orderMap.get(a) - orderMap.get(b));
        Collections.sort(list2);
        int[] sorted = new int[length1];
        int index = 0;
        for (int num : list1) {
            sorted[index++] = num;
        }
        for (int num : list2) {
            sorted[index++] = num;
        }
        return sorted;
    }
}