GFG App
Open App
Browser
Continue

# Merge two Maps of Array into one sorted Map of Array

Given two maps map1 and map2 having a string as the key and arrays of integers as values, the task is to merge them in one map such that if a key is common in both the maps, the respective arrays should be merged.

Examples:

Input: map1 = { (“key1”, {0, 1}), (“key2”, {0, 1}) }, map2 = { (“key2”, {1, 2}) };
Output: { (key1, {0, 1}), (key2, {0, 1, 2}) }
Explanation: After merging key1 array will become {0, 1} and for key2 after merging array will become {0, 1, 2}

Input: map1 = {(“key1”, {0, 1})}, map2 = {(“key2”, {1, 2})};
Output: {(key1, [0, 1]), (key2, [1, 2])}

Approach: The solution to the problem is based on the concept of merging two arrays. Follow the steps mentioned below:

• Create a map to store the merged maps
• Traverse map1 and store all the key-value pairs in map1.
• Traverse map2 and:
• If the key of map2 does not exists in map1, just insert this key value pair in map1
• If the key of map2 exists in map1,
• Take the array of map1 and array of map2
• Sort both the arrays, and
• Merge them using approach mentioned in merge two arrays.
• Return the map3 at the end.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the approach` `#include ` `using` `namespace` `std;`   `// Function to merge arrays` `vector<``int``> mergeArrays(vector<``int``>& a, vector<``int``>& b,` `                        ``int` `n, ``int` `m)` `{` `    ``vector<``int``> mergedArray;`   `    ``// Declaring a map.` `    ``// Using map as a inbuilt tool` `    ``// to store elements in sorted order.` `    ``map<``int``, ``bool``> mp;`   `    ``// Inserting values to a map.` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``mp[a[i]] = ``true``;`   `    ``for` `(``int` `i = 0; i < m; i++)` `        ``mp[b[i]] = ``true``;`   `    ``// Printing keys of the map.` `    ``for` `(``auto` `i : mp)` `        ``mergedArray.push_back(i.first);` `    ``return` `mergedArray;` `}`   `// Function to merge maps` `map >` `mergeMap(map >& map1,` `         ``map >& map2)` `{` `    ``map > map3;` `    ``map3.insert(map1.begin(), map1.end());`   `    ``for` `(``auto` `itr : map2) {` `        ``if` `(map3.find(itr.first) == map3.end())` `            ``map3.insert({ itr.first, itr.second });` `        ``else` `{` `            ``auto` `temp_itr = map3.find(itr.first);` `            ``vector<``int``> arr = mergeArrays(` `                ``itr.second, temp_itr->second,` `                ``itr.second.size(),` `                ``temp_itr->second.size());` `            ``map3[itr.first] = arr;` `        ``}` `    ``}` `    ``return` `map3;` `}`   `// Driver code` `int` `main()` `{` `    ``map > map1, map2, map3;` `    ``map1.insert({ ``"key1"``, { 0, 1 } });` `    ``map1.insert({ ``"key2"``, { 0, 1 } });` `    ``map2.insert({ ``"key2"``, { 1, 2 } });`   `    ``// Function call` `    ``map3 = mergeMap(map1, map2);`   `    ``for` `(``auto` `itr : map3) {` `        ``cout << ``"\""` `<< itr.first << ``"\", { "``;` `        ``for` `(``auto` `x : itr.second)` `            ``cout << x << ``" "``;` `        ``cout << ``"}\n"``;` `    ``}` `    ``return` `0;` `}`

## Java

 `/*package whatever //do not write package name here */`   `import` `java.util.*;`   `class` `GFG {` ` ``public` `static` `Vector mergeArrays(Vector a, ` `                                           ``Vector b, ``int` `n, ``int` `m) {` `    ``Vector mergedArray = ``new` `Vector();`   `    ``// Declaring a map.` `    ``// Using map as a inbuilt tool` `    ``// to store elements in sorted order.` `    ``Map mp = ``new` `HashMap();`   `    ``// Inserting values to a map.` `    ``for` `(``int` `i = ``0``; i < n; i++)` `        ``mp.put(a.get(i), ``true``);`   `    ``for` `(``int` `i = ``0``; i < m; i++)` `        ``mp.put(b.get(i), ``true``);`   `    ``// Printing keys of the map.` `    ``for` `(Map.Entry i : mp.entrySet())` `        ``mergedArray.add(i.getKey());` `    ``return` `mergedArray;` `}`   `public` `static` `Map> mergeMap(Map> map1, Map> map2) {` `    ``Map> map3 = ``new` `HashMap>();` `    ``map3.putAll(map1);`   `    ``for` `(Map.Entry> itr : map2.entrySet()) {` `        ``if` `(!map3.containsKey(itr.getKey()))` `            ``map3.put(itr.getKey(), itr.getValue());` `        ``else` `{` `            ``Vector temp_itr = map3.get(itr.getKey());` `            ``Vector arr = mergeArrays(itr.getValue(), ` `                                 ``temp_itr, itr.getValue().size(), temp_itr.size());` `            ``map3.put(itr.getKey(), arr);` `        ``}` `    ``}` `    ``return` `map3;` `}`   `public` `static` `void` `main(String[] args) {` `    ``Map> map1 = ``new` `HashMap>();` `    ``Map> map2 = ``new` `HashMap>();` `    ``Map> map3 = ``new` `HashMap>();` `    ``map1.put(``"key1"``, ``new` `Vector(Arrays.asList(``0``, ``1``)));` `    ``map1.put(``"key2"``, ``new` `Vector(Arrays.asList(``0``, ``1``)));` `    ``map2.put(``"key2"``, ``new` `Vector(Arrays.asList(``1``, ``2``)));`   `    ``map3 = mergeMap(map1, map2);`   `    ``for` `(Map.Entry> itr : map3.entrySet()) {` `        ``System.out.print(``"\""` `+ itr.getKey() + ``"\", { "``);` `        ``for` `(``int` `x : itr.getValue())` `            ``System.out.print(x + ``" "``);` `        ``System.out.println(``"}"``);` `    ``}` `}` `}`

## Python3

 `# Python code to implement the approach`   `# Function to merge arrays` `def` `mergeArrays (a, b, n, m):` `    ``mergedArray ``=` `[];`   `    ``# Declaring a map.` `    ``# Using map as a inbuilt tool` `    ``# to store elements in sorted order.` `    ``mp ``=` `{};`   `    ``# Inserting values to a map.` `    ``for` `i ``in` `range``(n):` `        ``mp[a[i]] ``=` `True``;`   `    ``for` `i ``in` `range``(m):` `        ``mp[b[i]] ``=` `True``;`   `    ``# Printing keys of the map.` `    ``for` `i ``in` `mp:` `        ``mergedArray.append(i);`   `    ``return` `mergedArray;`   `# Function to merge maps` `def` `mergeMap (map1, map2):` `    ``map3 ``=` `{};` `    ``for` `itm ``in` `map1.keys():` `        ``map3[itm] ``=` `map1[itm];`   `    ``for` `itr ``in` `map2.keys():` `        ``if` `(``not` `itr ``in` `map3.keys()):` `            ``map3[itr] ``=` `map2[itr];` `        ``else``:` `            ``arr ``=` `mergeArrays(map2[itr], map3[itr], ``len``(map2[itr]), ``len``(map3[itr]));`   `            ``map3[itr] ``=` `arr;`   `    ``return` `map3;`   `# Driver code` `map1 ``=` `{}` `map2 ``=` `{}` `map3 ``=` `{};`   `map1[``"key1"``] ``=` `[``0``, ``1``];` `map1[``"key2"``] ``=` `[``0``, ``1``];` `map2[``"key2"``] ``=` `[``1``, ``2``];`   `# Function call` `map3 ``=` `mergeMap(map1, map2);`   `for` `itr ``in` `map3.keys():` `    ``print``(f``"\"{itr}\", {{"``, end``=``" "``)` `    ``map3[itr].sort()` `    ``for` `x ``in` `map3[itr]:` `        ``print``(map3[itr][x], end``=``" "``);` `    ``print``(``"} "``);`   `# This code is contributed by Saurabh Jaiswal`

## Javascript

 ``

## C#

 `// C# code to implement the approach` `using` `System;` `using` `System.Collections.Generic;`   `namespace` `MergeMaps` `{` `    ``class` `Program` `    ``{` `        ``// Function to merge arrays` `        ``static` `List<``int``> MergeArrays(List<``int``> a, List<``int``> b, ``int` `n, ``int` `m)` `        ``{` `            ``List<``int``> mergedArray = ``new` `List<``int``>();`   `            ``// Declaring a dictionary` `            ``Dictionary<``int``, ``bool``> dict = ``new` `Dictionary<``int``, ``bool``>();`   `            ``// Inserting values to a dictionary` `            ``foreach` `(``int` `i ``in` `a)` `                ``dict[i] = ``true``;`   `            ``foreach` `(``int` `i ``in` `b)` `                ``dict[i] = ``true``;`   `            ``// Printing keys of the dictionary` `            ``foreach` `(``var` `i ``in` `dict.Keys)` `                ``mergedArray.Add(i);`   `            ``return` `mergedArray;` `        ``}`   `        ``// Function to merge dictionaries` `        ``static` `Dictionary<``string``, List<``int``>> MergeMap(Dictionary<``string``, List<``int``>> map1, Dictionary<``string``, List<``int``>> map2)` `        ``{` `            ``Dictionary<``string``, List<``int``>> map3 = ``new` `Dictionary<``string``, List<``int``>>();` `            ``foreach` `(``var` `item ``in` `map1)` `                ``map3[item.Key] = item.Value;`   `            ``foreach` `(``var` `itr ``in` `map2)` `            ``{` `                ``if` `(!map3.ContainsKey(itr.Key))` `                    ``map3[itr.Key] = itr.Value;` `                ``else` `                ``{` `                    ``var` `temp_itr = map3[itr.Key];` `                    ``List<``int``> arr = MergeArrays(itr.Value, temp_itr, itr.Value.Count, temp_itr.Count);` `                    ``map3[itr.Key] = arr;` `                ``}` `            ``}` `            ``return` `map3;` `        ``}`   `        ``static` `void` `Main(``string``[] args)` `        ``{` `            ``Dictionary<``string``, List<``int``>> map1 = ``new` `Dictionary<``string``, List<``int``>>();` `            ``Dictionary<``string``, List<``int``>> map2 = ``new` `Dictionary<``string``, List<``int``>>();` `            ``Dictionary<``string``, List<``int``>> map3 = ``new` `Dictionary<``string``, List<``int``>>();`   `            ``map1[``"key1"``] = ``new` `List<``int``> { 0, 1 };` `            ``map1[``"key2"``] = ``new` `List<``int``> { 0, 1 };` `            ``map2[``"key2"``] = ``new` `List<``int``> { 1, 2 };`   `            ``// Function call` `            ``map3 = MergeMap(map1, map2);`   `            ``foreach` `(``var` `itr ``in` `map3)` `            ``{` `                ``Console.Write(``"\""` `+ itr.Key + ``"\", { "``);` `                ``foreach` `(``var` `x ``in` `itr.Value)` `                    ``Console.Write(x + ``" "``);` `                ``Console.WriteLine(``"}"``);` `            ``}` `        ``}` `    ``}` `}`

Output

```"key1", { 0 1 }
"key2", { 0 1 2 }```

Time Complexity: O(N * log N + M * log M)
Auxiliary Space: O(M + N

## C++

 `// C++ code to implement the approach` `#include ` `using` `namespace` `std;`   `// Function to merge arrays` `vector<``int``> mergeArrays(vector<``int``>& a, vector<``int``>& b,` `                        ``int` `n, ``int` `m)` `{` `    ``vector<``int``> mergedArray;`   `    ``// Declaring a map.` `    ``// Using map as a inbuilt tool` `    ``// to store elements in sorted order.` `    ``map<``int``, ``bool``> mp;`   `    ``// Inserting values to a map.` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``mp[a[i]] = ``true``;`   `    ``for` `(``int` `i = 0; i < m; i++)` `        ``mp[b[i]] = ``true``;`   `    ``// Printing keys of the map.` `    ``for` `(``auto` `i : mp)` `        ``mergedArray.push_back(i.first);` `    ``return` `mergedArray;` `}`   `// Function to merge maps` `map >` `mergeMap(map >& map1,` `         ``map >& map2)` `{` `    ``map > map3;` `    ``map3.insert(map1.begin(), map1.end());`   `    ``for` `(``auto` `itr : map2) {` `        ``if` `(map3.find(itr.first) == map3.end())` `            ``map3.insert({ itr.first, itr.second });` `        ``else` `{` `            ``auto` `temp_itr = map3.find(itr.first);` `            ``vector<``int``> arr = mergeArrays(` `                ``itr.second, temp_itr->second,` `                ``itr.second.size(), temp_itr->second.size());` `            ``map3[itr.first] = arr;` `        ``}` `    ``}` `    ``return` `map3;` `}`   `// Driver code` `int` `main()` `{` `    ``map > map1, map2, map3;` `    ``map1.insert({ ``"key1"``, { 0, 1 } });` `    ``map1.insert({ ``"key2"``, { 0, 1 } });` `    ``map2.insert({ ``"key2"``, { 1, 2 } });`   `    ``// Function call` `    ``map3 = mergeMap(map1, map2);`   `    ``for` `(``auto` `itr : map3) {` `        ``cout << ``"\""` `<< itr.first << ``"\", { "``;` `        ``for` `(``auto` `x : itr.second)` `            ``cout << x << ``" "``;` `        ``cout << ``"}\n"``;` `    ``}` `    ``return` `0;` `}`

## Java

 `/*package whatever //do not write package name here */`   `import` `java.util.*;`   `class` `GFG {` ` ``public` `static` `Vector mergeArrays(Vector a, ` `                                           ``Vector b, ``int` `n, ``int` `m) {` `    ``Vector mergedArray = ``new` `Vector();`   `    ``// Declaring a map.` `    ``// Using map as a inbuilt tool` `    ``// to store elements in sorted order.` `    ``Map mp = ``new` `HashMap();`   `    ``// Inserting values to a map.` `    ``for` `(``int` `i = ``0``; i < n; i++)` `        ``mp.put(a.get(i), ``true``);`   `    ``for` `(``int` `i = ``0``; i < m; i++)` `        ``mp.put(b.get(i), ``true``);`   `    ``// Printing keys of the map.` `    ``for` `(Map.Entry i : mp.entrySet())` `        ``mergedArray.add(i.getKey());` `    ``return` `mergedArray;` `}`   `public` `static` `Map> mergeMap(Map> map1, Map> map2) {` `    ``Map> map3 = ``new` `HashMap>();` `    ``map3.putAll(map1);`   `    ``for` `(Map.Entry> itr : map2.entrySet()) {` `        ``if` `(!map3.containsKey(itr.getKey()))` `            ``map3.put(itr.getKey(), itr.getValue());` `        ``else` `{` `            ``Vector temp_itr = map3.get(itr.getKey());` `            ``Vector arr = mergeArrays(itr.getValue(), ` `                                 ``temp_itr, itr.getValue().size(), temp_itr.size());` `            ``map3.put(itr.getKey(), arr);` `        ``}` `    ``}` `    ``return` `map3;` `}`   `public` `static` `void` `main(String[] args) {` `    ``Map> map1 = ``new` `HashMap>();` `    ``Map> map2 = ``new` `HashMap>();` `    ``Map> map3 = ``new` `HashMap>();` `    ``map1.put(``"key1"``, ``new` `Vector(Arrays.asList(``0``, ``1``)));` `    ``map1.put(``"key2"``, ``new` `Vector(Arrays.asList(``0``, ``1``)));` `    ``map2.put(``"key2"``, ``new` `Vector(Arrays.asList(``1``, ``2``)));`   `    ``map3 = mergeMap(map1, map2);`   `    ``for` `(Map.Entry> itr : map3.entrySet()) {` `        ``System.out.print(``"\""` `+ itr.getKey() + ``"\", { "``);` `        ``for` `(``int` `x : itr.getValue())` `            ``System.out.print(x + ``" "``);` `        ``System.out.println(``"}"``);` `    ``}` `}` `}`

## Python3

 `# Python code to implement the approach`   `# Function to merge arrays` `def` `mergeArrays (a, b, n, m):` `    ``mergedArray ``=` `[];`   `    ``# Declaring a map.` `    ``# Using map as a inbuilt tool` `    ``# to store elements in sorted order.` `    ``mp ``=` `{};`   `    ``# Inserting values to a map.` `    ``for` `i ``in` `range``(n):` `        ``mp[a[i]] ``=` `True``;`   `    ``for` `i ``in` `range``(m):` `        ``mp[b[i]] ``=` `True``;`   `    ``# Printing keys of the map.` `    ``for` `i ``in` `mp:` `        ``mergedArray.append(i);`   `    ``return` `mergedArray;`   `# Function to merge maps` `def` `mergeMap (map1, map2):` `    ``map3 ``=` `{};` `    ``for` `itm ``in` `map1.keys():` `        ``map3[itm] ``=` `map1[itm];`   `    ``for` `itr ``in` `map2.keys():` `        ``if` `(``not` `itr ``in` `map3.keys()):` `            ``map3[itr] ``=` `map2[itr];` `        ``else``:` `            ``arr ``=` `mergeArrays(map2[itr], map3[itr], ``len``(map2[itr]), ``len``(map3[itr]));`   `            ``map3[itr] ``=` `arr;`   `    ``return` `map3;`   `# Driver code` `map1 ``=` `{}` `map2 ``=` `{}` `map3 ``=` `{};`   `map1[``"key1"``] ``=` `[``0``, ``1``];` `map1[``"key2"``] ``=` `[``0``, ``1``];` `map2[``"key2"``] ``=` `[``1``, ``2``];`   `# Function call` `map3 ``=` `mergeMap(map1, map2);`   `for` `itr ``in` `map3.keys():` `    ``print``(f``"\"{itr}\", {{"``, end``=``" "``)` `    ``map3[itr].sort()` `    ``for` `x ``in` `map3[itr]:` `        ``print``(map3[itr][x], end``=``" "``);` `    ``print``(``"} "``);`   `# This code is contributed by Saurabh Jaiswal`

## Javascript

 ``

## C#

 `// C# code to implement the approach` `using` `System;` `using` `System.Collections.Generic;`   `namespace` `MergeMaps` `{` `    ``class` `Program` `    ``{` `        ``// Function to merge arrays` `        ``static` `List<``int``> MergeArrays(List<``int``> a, List<``int``> b, ``int` `n, ``int` `m)` `        ``{` `            ``List<``int``> mergedArray = ``new` `List<``int``>();`   `            ``// Declaring a dictionary` `            ``Dictionary<``int``, ``bool``> dict = ``new` `Dictionary<``int``, ``bool``>();`   `            ``// Inserting values to a dictionary` `            ``foreach` `(``int` `i ``in` `a)` `                ``dict[i] = ``true``;`   `            ``foreach` `(``int` `i ``in` `b)` `                ``dict[i] = ``true``;`   `            ``// Printing keys of the dictionary` `            ``foreach` `(``var` `i ``in` `dict.Keys)` `                ``mergedArray.Add(i);`   `            ``return` `mergedArray;` `        ``}`   `        ``// Function to merge dictionaries` `        ``static` `Dictionary<``string``, List<``int``>> MergeMap(Dictionary<``string``, List<``int``>> map1, Dictionary<``string``, List<``int``>> map2)` `        ``{` `            ``Dictionary<``string``, List<``int``>> map3 = ``new` `Dictionary<``string``, List<``int``>>();` `            ``foreach` `(``var` `item ``in` `map1)` `                ``map3[item.Key] = item.Value;`   `            ``foreach` `(``var` `itr ``in` `map2)` `            ``{` `                ``if` `(!map3.ContainsKey(itr.Key))` `                    ``map3[itr.Key] = itr.Value;` `                ``else` `                ``{` `                    ``var` `temp_itr = map3[itr.Key];` `                    ``List<``int``> arr = MergeArrays(itr.Value, temp_itr, itr.Value.Count, temp_itr.Count);` `                    ``map3[itr.Key] = arr;` `                ``}` `            ``}` `            ``return` `map3;` `        ``}`   `        ``static` `void` `Main(``string``[] args)` `        ``{` `            ``Dictionary<``string``, List<``int``>> map1 = ``new` `Dictionary<``string``, List<``int``>>();` `            ``Dictionary<``string``, List<``int``>> map2 = ``new` `Dictionary<``string``, List<``int``>>();` `            ``Dictionary<``string``, List<``int``>> map3 = ``new` `Dictionary<``string``, List<``int``>>();`   `            ``map1[``"key1"``] = ``new` `List<``int``> { 0, 1 };` `            ``map1[``"key2"``] = ``new` `List<``int``> { 0, 1 };` `            ``map2[``"key2"``] = ``new` `List<``int``> { 1, 2 };`   `            ``// Function call` `            ``map3 = MergeMap(map1, map2);`   `            ``foreach` `(``var` `itr ``in` `map3)` `            ``{` `                ``Console.Write(``"\""` `+ itr.Key + ``"\", { "``);` `                ``foreach` `(``var` `x ``in` `itr.Value)` `                    ``Console.Write(x + ``" "``);` `                ``Console.WriteLine(``"}"``);` `            ``}` `        ``}` `    ``}` `}`

My Personal Notes arrow_drop_up