# Print elements of an array according to the order defined by another array | set 2

Given two arrays a1[] and a2[], print elements of a1 in such a way that the relative order among the elements will be the same as those are in a2. That is, elements which come before in the array a2[], print those elements first from the array a1[]. For the elements not present in a2, print them at last in sorted order.

It is also given that the number of elements in a2[] is smaller than or equal to the number of elements in a1[], and a2[] has all distinct elements.**Example:**

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

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

a2[] = {1, 10, 11}Output:1 1 2 2 3 5 6 7 8 8 9

**Simple Approach:** We create a temporary array and a visited array where the temporary array is used to copy contents of a1[] to it and visited array is used to mark those elements in the temporary array which are copied to a1[]. Then sorting the temporary array and doing a binary search for every element of a2[] in a1[]. You can find the solution here.**Efficient Approach:** We can print the elements of a1[] according to the order defined by a2[] using **map in c++** in O(mlog(n)) time. We traverse through a1[] and store the frequency of every number in a map. Then we traverse through a2[] and check if the number is present in the map. If the number is present, then print it that many times and erase the number from the map. Print the rest of the numbers present in the map sequentially as numbers are stored in the map in sorted order.

Below is the implementation of the above approach:

## C++

`// A C++ program to print an array according` `// to the order defined by another array` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to print an array according` `// to the order defined by another array` `void` `print_in_order(` `int` `a1[], ` `int` `a2[], ` `int` `n, ` `int` `m)` `{` ` ` `// Declaring map and iterator` ` ` `map<` `int` `, ` `int` `> mp;` ` ` `map<` `int` `, ` `int` `>::iterator itr;` ` ` `// Store the frequency of each` ` ` `// number of a1[] int the map` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `mp[a1[i]]++;` ` ` `// Traverse through a2[]` ` ` `for` `(` `int` `i = 0; i < m; i++) {` ` ` `// Check whether number` ` ` `// is present in map or not` ` ` `if` `(mp.find(a2[i]) != mp.end()) {` ` ` `itr = mp.find(a2[i]);` ` ` `// Print that number that` ` ` `// many times of its frequency` ` ` `for` `(` `int` `j = 0; j < itr->second; j++)` ` ` `cout << itr->first << ` `" "` `;` ` ` `mp.erase(a2[i]);` ` ` `}` ` ` `}` ` ` `// Print those numbers that are not` ` ` `// present in a2[]` ` ` `for` `(itr = mp.begin(); itr != mp.end(); itr++) {` ` ` `for` `(` `int` `j = 0; j < itr->second; j++)` ` ` `cout << itr->first << ` `" "` `;` ` ` `}` ` ` `cout << endl;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `a1[] = { 2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8 };` ` ` `int` `a2[] = { 2, 1, 8, 3 };` ` ` `int` `n = ` `sizeof` `(a1) / ` `sizeof` `(a1[0]);` ` ` `int` `m = ` `sizeof` `(a2) / ` `sizeof` `(a2[0]);` ` ` `print_in_order(a1, a2, n, m);` ` ` `return` `0;` `}` |

## Python3

`# A Python3 program to print an array according` `# to the order defined by another array` `# Function to print an array according` `# to the order defined by another array` `def` `print_in_order(a1, a2, n, m) :` ` ` `# Declaring map and iterator` ` ` `mp ` `=` `dict` `.fromkeys(a1,` `0` `);` ` ` `# Store the frequency of each` ` ` `# number of a1[] int the map` ` ` `for` `i ` `in` `range` `(n) :` ` ` `mp[a1[i]] ` `+` `=` `1` `;` ` ` `# Traverse through a2[]` ` ` `for` `i ` `in` `range` `(m) :` ` ` `# Check whether number` ` ` `# is present in map or not` ` ` `if` `a2[i] ` `in` `mp.keys() :` ` ` `# Print that number that` ` ` `# many times of its frequency` ` ` `for` `j ` `in` `range` `(mp[a2[i]]) :` ` ` `print` `(a2[i],end` `=` `" "` `);` ` ` ` ` `del` `(mp[a2[i]]);` ` ` `# Print those numbers that are not` ` ` `# present in a2[]` ` ` `for` `key,value ` `in` `mp.items() :` ` ` `for` `j ` `in` `range` `(value) :` ` ` `print` `(key,end` `=` `" "` `);` ` ` `print` `();` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `a1 ` `=` `[ ` `2` `, ` `1` `, ` `2` `, ` `5` `, ` `7` `, ` `1` `, ` `9` `, ` `3` `, ` `6` `, ` `8` `, ` `8` `];` ` ` `a2 ` `=` `[ ` `2` `, ` `1` `, ` `8` `, ` `3` `];` ` ` `n ` `=` `len` `(a1);` ` ` `m ` `=` `len` `(a2);` ` ` `print_in_order(a1, a2, n, m);` ` ` ` ` `# This code is contributed by AnkitRai01` |

**Output:**

2 2 1 1 8 8 3 5 6 7 9

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.