oj-按照另一个数组排序-java

Description

Given two array A1[] and A2[], sort A1 in such a way that the relative order among the elements will be same as those in A2. For the elements not present in A2. Append them at last in sorted order. It is also given that the number of elements in A2[] are smaller than or equal to number of elements in A1[] and A2[] has all distinct elements.

Input:A1[] = {2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8} A2[] = {2, 1, 8, 3}Output: A1[] = {2, 2, 1, 1, 8, 8, 3, 5, 6, 7, 9}

Since 2 is present first in A2[], all occurrences of 2s should appear first in A[], then all occurrences 1s as 1 comes after 2 in A[]. Next all occurrences of 8 and then all occurrences of 3. Finally we print all those elements of A1[] that are not present in A2[]

Constraints:1 ≤ T ≤ 501 ≤ M ≤ 501 ≤ N ≤ 10 & N ≤ M1 ≤ A1[i], A2[i] ≤ 1000

Input

The first line of input contains an integer T denoting the number of test cases. The first line of each test case is M and N. M is the number of elements in A1 and N is the number of elements in A2.The second line of each test case contains M elements. The third line of each test case contains N elements.

Output

Print the sorted array according order defined by another array.

Sample Input 1

1
11 4
2 1 2 5 7 1 9 3 6 8 8
2 1 8 3

Sample Output 1

2 2 1 1 8 8 3 5 6 7 9

Code

package org.alphacat.second;

import java.util.*;

public class SortByAnotherArr {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = scanner.nextInt();
        for (int p = 0; p < t; p++) {
            int n = scanner.nextInt();
            int m = scanner.nextInt();
            int[] a1 = new int[n];
            int[] a2 = new int[m];
            for (int i = 0; i < n; i++) {
                a1[i] = scanner.nextInt();
            }
            for (int i = 0; i < m; i++) {
                a2[i] = scanner.nextInt();
            }
            int[] res = problem(a1, a2);
            println(res);
        }
    }

    private static int[] problem(int[] a1, int[] a2) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int num : a2) {
            map.put(num, 0);
        }
        List<Integer> temp = new ArrayList<>(a1.length);
        for (int num : a1) {
            if (map.containsKey(num)) {
                map.put(num, map.get(num) + 1);
            } else {
                temp.add(num);
            }
        }

        int[] res = new int[a1.length];
        int index = 0;

        for (int num : a2) {
            int cnt = map.get(num);
            for (int i = 0; i < cnt; i++) {
                res[index++] = num;
            }
        }

        int beginSortIndex = index;

        for (int num : temp) {
            res[index++] = num;
        }
        Arrays.sort(res, beginSortIndex, res.length);
        return res;
    }

    private static void println(int[] arr) {
        String res = getString(arr);
        System.out.println(res);
    }

    private static String getString(int[] arr) {
        int n = arr.length;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            sb.append(arr[i]);
            if (i != n - 1) {
                sb.append(" ");
            }
        }
        return sb.toString();
    }
}