Maximize elements using another array
Last Updated :
27 Apr, 2025
Improve
Given two arrays a[] and b[] of size n. The task is to maximize the first array by using the elements from the second array such that the new array formed contains n greatest but unique elements of both the arrays giving the second array priority (All elements of second array appear before first array). The order of appearance of elements is kept same in output as in input.
Examples:
Input: a[] = [2, 4, 3] , b[] = [5, 6, 1]
Output: 5 6 4
Explanation: As 5, 6 and 4 are maximum elements from two arrays giving second array higher priority. Order of elements is same in output as in input.Input: a[] = [7, 4, 8, 0, 1] , b[] = [9, 10, 2, 3, 6]
Output: 9 10 6 7 8
Explanation: As 9, 7, 6, 4 and 8 are maximum elements from two arrays giving second array higher priority. Order of elements is same in output as in input.
Try it on GfG Practice 
Table of Content
Using Sorting – O(n log n) Time and O(n) Space
The idea is to first concatenate both arrays, then sort them in descending order to easily pick the largest elements. Using a hash set, we extract the n largest unique elements. Finally, we maintain the relative order of elements, first from b[], then from a[], to construct the result.
// C++ program to maximize array elements
// giving second array higher priority
#include <bits/stdc++.h>
using namespace std;
// Compare function to sort elements
// in decreasing order
bool compare(int x, int y) {
return x > y;
}
// Function to maximize array elements
vector<int> maximizeArray(vector<int>& a,
vector<int>& b) {
int n = a.size();
// Auxiliary vector to store
// elements of a and b
vector<int> merged(2 * n);
int k = 0;
// Copy elements from both arrays into merged
for (int i = 0; i < n; i++) {
merged[k++] = a[i];
}
for (int i = 0; i < n; i++) {
merged[k++] = b[i];
}
// Hash set to store n largest
// unique elements
unordered_set<int> hash;
// Sorting merged array in decreasing order
sort(merged.begin(), merged.end(), compare);
// Finding n largest unique elements
// and storing in hash
int i = 0;
while (hash.size() < n) {
// If the element is not in hash, insert it
if (hash.find(merged[i]) == hash.end()) {
hash.insert(merged[i]);
}
i++;
}
vector<int> result;
// Store elements of b in result that
// are present in hash
for (int i = 0; i < n; i++) {
if (hash.find(b[i]) != hash.end()) {
result.push_back(b[i]);
hash.erase(b[i]);
}
}
// Store elements of a in result that
// are present in hash
for (int i = 0; i < n; i++) {
if (hash.find(a[i]) != hash.end()) {
result.push_back(a[i]);
hash.erase(a[i]);
}
}
return result;
}
// Driver Code
int main() {
// Input arrays
vector<int> a = {7, 4, 8, 0, 1};
vector<int> b = {9, 7, 2, 3, 6};
vector<int> res = maximizeArray(a, b);
for (int num : res) {
cout << num << " ";
}
cout << endl;
return 0;
}
91
1
// C++ program to maximize array elements2
// giving second array higher priority3
4
using namespace std;5
6
// Compare function to sort elements7
// in decreasing order8
bool compare(int x, int y) {9
return x > y;10
}11
12
// Function to maximize array elements13
vector<int> maximizeArray(vector<int>& a, 14
vector<int>& b) {15
16
int n = a.size();17
18
// Auxiliary vector to store 19
// elements of a and b20
vector<int> merged(2 * n);21
22
int k = 0;23
24
// Copy elements from both arrays into merged25
for (int i = 0; i < n; i++) {26
merged[k++] = a[i];27
}28
for (int i = 0; i < n; i++) {29
merged[k++] = b[i];30
}31
32
// Hash set to store n largest33
// unique elements34
unordered_set<int> hash;35
36
// Sorting merged array in decreasing order37
sort(merged.begin(), merged.end(), compare);38
39
// Finding n largest unique elements 40
// and storing in hash41
int i = 0;42
while (hash.size() < n) {43
44
// If the element is not in hash, insert it45
if (hash.find(merged[i]) == hash.end()) {46
hash.insert(merged[i]);47
}48
49
i++;50
}51
52
vector<int> result;53
54
// Store elements of b in result that55
// are present in hash56
for (int i = 0; i < n; i++) {57
if (hash.find(b[i]) != hash.end()) {58
result.push_back(b[i]);59
hash.erase(b[i]);60
}61
}62
63
// Store elements of a in result that64
// are present in hash65
for (int i = 0; i < n; i++) {66
if (hash.find(a[i]) != hash.end()) {67
result.push_back(a[i]);68
hash.erase(a[i]);69
}70
}71
72
return result;73
}74
75
76
// Driver Code77
int main() {78
79
// Input arrays80
vector<int> a = {7, 4, 8, 0, 1};81
vector<int> b = {9, 7, 2, 3, 6};82
83
vector<int> res = maximizeArray(a, b);84
85
for (int num : res) {86
cout << num << " ";87
}88
cout << endl;89
90
return 0;91
}// Java program to maximize array elements
// giving second array higher priority
import java.util.*;
class GfG {
// Compare function to sort elements
// in decreasing order
static Comparator<Integer> compare =
(x, y) -> Integer.compare(y, x);
// Function to maximize array elements
static int[] maximizeArray(int[] a, int[] b) {
int n = a.length;
// Auxiliary array to store
// elements of a and b
int[] merged = new int[2 * n];
int k = 0;
// Copy elements from both arrays into merged
for (int i = 0; i < n; i++) {
merged[k++] = a[i];
}
for (int i = 0; i < n; i++) {
merged[k++] = b[i];
}
// Hash set to store n largest
// unique elements
Set<Integer> hash = new HashSet<>();
// Sorting merged array in decreasing order
Arrays.sort(merged);
Integer[] temp = Arrays.stream(merged)
.boxed()
.toArray(Integer[]::new);
Arrays.sort(temp, compare);
// Finding n largest unique elements
// and storing in hash
int i = 0;
while (hash.size() < n) {
// If the element is not in hash, insert it
if (!hash.contains(temp[i])) {
hash.add(temp[i]);
}
i++;
}
int[] result = new int[n];
k = 0;
// Store elements of b in result that
// are present in hash
for (int x : b) {
if (hash.contains(x)) {
result[k++] = x;
hash.remove(x);
}
}
// Store elements of a in result that
// are present in hash
for (int x : a) {
if (hash.contains(x)) {
result[k++] = x;
hash.remove(x);
}
}
return result;
}
// Function to print array elements
static void printArray(int[] arr) {
for (int num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
// Driver Code
public static void main(String[] args) {
int[] a = {7, 4, 8, 0, 1};
int[] b = {9, 7, 2, 3, 6};
int[] result = maximizeArray(a, b);
printArray(result);
}
}
# Python program to maximize array elements
# giving second array higher priority
# Function to maximize array elements
def maximizeArray(a, b):
n = len(a)
# Auxiliary list to store elements of a and b
merged = a + b
# Hash set to store n largest unique elements
hash_set = set()
# Sorting merged array in decreasing order
merged.sort(reverse=True)
# Finding n largest unique elements
# and storing in hash_set
i = 0
while len(hash_set) < n:
# If the element is not in hash_set, insert it
if merged[i] not in hash_set:
hash_set.add(merged[i])
i += 1
result = []
# Store elements of b in result that
# are present in hash_set
for x in b:
if x in hash_set:
result.append(x)
hash_set.remove(x)
# Store elements of a in result that
# are present in hash_set
for x in a:
if x in hash_set:
result.append(x)
hash_set.remove(x)
return result
# Function to print array elements
def printArray(arr):
print(" ".join(map(str, arr)))
# Driver Code
if __name__ == "__main__":
# Input arrays
a = [7, 4, 8, 0, 1]
b = [9, 7, 2, 3, 6]
result = maximizeArray(a, b)
printArray(result)
// C# program to maximize array elements
// giving second array higher priority
using System;
using System.Collections.Generic;
using System.Linq;
class GfG {
// Compare function to sort elements
// in decreasing order
static int Compare(int x, int y) {
return y.CompareTo(x);
}
// Function to maximize array elements
static int[] maximizeArray(int[] a, int[] b) {
int n = a.Length;
// Auxiliary array to store
// elements of a and b
int[] merged = new int[2 * n];
int k = 0;
// Copy elements from both arrays into merged
for (int i = 0; i < n; i++) {
merged[k++] = a[i];
}
for (int i = 0; i < n; i++) {
merged[k++] = b[i];
}
// Hash set to store n largest
// unique elements
HashSet<int> hash = new HashSet<int>();
// Sorting merged array in decreasing order
Array.Sort(merged);
Array.Reverse(merged);
// Finding n largest unique elements
// and storing in hash
int j = 0;
while (hash.Count < n) {
// If the element is not in hash, insert it
if (!hash.Contains(merged[j])) {
hash.Add(merged[j]);
}
j++;
}
int[] result = new int[n];
k = 0;
// Store elements of b in result that
// are present in hash
for (int i = 0; i < n; i++) {
if (hash.Contains(b[i])) {
result[k++] = b[i];
hash.Remove(b[i]);
}
}
// Store elements of a in result that
// are present in hash
for (int i = 0; i < n; i++) {
if (hash.Contains(a[i])) {
result[k++] = a[i];
hash.Remove(a[i]);
}
}
return result;
}
// Function to print array elements
static void printArray(int[] arr) {
Console.WriteLine(string.Join(" ", arr));
}
// Driver Code
public static void Main() {
// Input arrays
int[] a = {7, 4, 8, 0, 1};
int[] b = {9, 7, 2, 3, 6};
int[] result = maximizeArray(a, b);
printArray(result);
}
}
// JavaScript program to maximize array elements
// giving second array higher priority
// Function to maximize array elements
function maximizeArray(a, b) {
let n = a.length;
// Auxiliary array to store elements of a and b
let merged = [...a, ...b];
// Hash set to store n largest unique elements
let hashSet = new Set();
// Sorting merged array in decreasing order
merged.sort((x, y) => y - x);
// Finding n largest unique elements
// and storing in hashSet
let i = 0;
while (hashSet.size < n) {
// If the element is not in hashSet, insert it
if (!hashSet.has(merged[i])) {
hashSet.add(merged[i]);
}
i++;
}
let result = [];
// Store elements of b in result that
// are present in hashSet
for (let x of b) {
if (hashSet.has(x)) {
result.push(x);
hashSet.delete(x);
}
}
// Store elements of a in result that
// are present in hashSet
for (let x of a) {
if (hashSet.has(x)) {
result.push(x);
hashSet.delete(x);
}
}
return result;
}
// Driver Code
let a = [7, 4, 8, 0, 1];
let b = [9, 7, 2, 3, 6];
console.log(maximizeArray(a, b).join(" "));
Output
9 7 6 4 8
Using Priority Queue – O(n log n) Time and O(n) Space
The idea is to use a priority queue. We push all elements into a max heap to efficiently extract the top n unique values. A hash set ensures uniqueness, and the result is constructed by preserving order from b[] first, then a[].
// C++ program to maximize array elements
// using priority queue for efficient selection
#include <bits/stdc++.h>
using namespace std;
// Function to maximize array elements
vector<int> maximizeArray(vector<int>& a,
vector<int>& b) {
int n = a.size();
// Max heap to store elements in
// decreasing order
priority_queue<int> pq;
// Hash set to ensure unique elements
unordered_set<int> hash;
// Insert all elements from a and b
// into max heap
for (int i = 0; i < n; i++) {
pq.push(a[i]);
pq.push(b[i]);
}
// Extract n largest unique elements
vector<int> largest;
while (!pq.empty() && largest.size() < n) {
int top = pq.top();
pq.pop();
if (hash.find(top) == hash.end()) {
hash.insert(top);
largest.push_back(top);
}
}
vector<int> result;
// Store elements of b in result that
// are present in hash
for (int i = 0; i < n; i++) {
if (hash.find(b[i]) != hash.end()) {
result.push_back(b[i]);
hash.erase(b[i]);
}
}
// Store elements of a in result that
// are present in hash
for (int i = 0; i < n; i++) {
if (hash.find(a[i]) != hash.end()) {
result.push_back(a[i]);
hash.erase(a[i]);
}
}
return result;
}
// Function to print array elements
void printArray(vector<int>& arr) {
for (int num : arr) {
cout << num << " ";
}
cout << endl;
}
// Driver Code
int main() {
vector<int> a = {7, 4, 8, 0, 1};
vector<int> b = {9, 7, 2, 3, 6};
vector<int> result = maximizeArray(a, b);
printArray(result);
return 0;
}
80
1
// C++ program to maximize array elements2
// using priority queue for efficient selection3
4
using namespace std;5
6
// Function to maximize array elements7
vector<int> maximizeArray(vector<int>& a, 8
vector<int>& b) {9
10
int n = a.size();11
12
// Max heap to store elements in 13
// decreasing order14
priority_queue<int> pq;15
16
// Hash set to ensure unique elements17
unordered_set<int> hash;18
19
// Insert all elements from a and b 20
// into max heap21
for (int i = 0; i < n; i++) {22
pq.push(a[i]);23
pq.push(b[i]);24
}25
26
// Extract n largest unique elements27
vector<int> largest;28
while (!pq.empty() && largest.size() < n) {29
int top = pq.top();30
pq.pop();31
32
if (hash.find(top) == hash.end()) {33
hash.insert(top);34
largest.push_back(top);35
}36
}37
38
vector<int> result;39
40
// Store elements of b in result that41
// are present in hash42
for (int i = 0; i < n; i++) {43
if (hash.find(b[i]) != hash.end()) {44
result.push_back(b[i]);45
hash.erase(b[i]);46
}47
}48
49
// Store elements of a in result that50
// are present in hash51
for (int i = 0; i < n; i++) {52
if (hash.find(a[i]) != hash.end()) {53
result.push_back(a[i]);54
hash.erase(a[i]);55
}56
}57
58
return result;59
}60
61
// Function to print array elements62
void printArray(vector<int>& arr) {63
for (int num : arr) {64
cout << num << " ";65
}66
cout << endl;67
}68
69
// Driver Code70
int main() {71
72
vector<int> a = {7, 4, 8, 0, 1};73
vector<int> b = {9, 7, 2, 3, 6};74
75
vector<int> result = maximizeArray(a, b);76
77
printArray(result);78
79
return 0;80
}// Java program to maximize array elements
// using priority queue for efficient selection
import java.util.*;
class GfG {
// Function to maximize array elements
static int[] maximizeArray(int[] a, int[] b) {
int n = a.length;
// Max heap to store elements in
// decreasing order
PriorityQueue<Integer> pq =
new PriorityQueue<>(Collections.reverseOrder());
// Hash set to ensure unique elements
HashSet<Integer> hash = new HashSet<>();
// Insert all elements from a and b
// into max heap
for (int i = 0; i < n; i++) {
pq.add(a[i]);
pq.add(b[i]);
}
// Extract n largest unique elements
List<Integer> largest = new ArrayList<>();
while (!pq.isEmpty() && largest.size() < n) {
int top = pq.poll();
if (!hash.contains(top)) {
hash.add(top);
largest.add(top);
}
}
int[] result = new int[n];
int k = 0;
// Store elements of b in result that
// are present in hash
for (int i = 0; i < n; i++) {
if (hash.contains(b[i])) {
result[k++] = b[i];
hash.remove(b[i]);
}
}
// Store elements of a in result that
// are present in hash
for (int i = 0; i < n; i++) {
if (hash.contains(a[i])) {
result[k++] = a[i];
hash.remove(a[i]);
}
}
return result;
}
// Function to print array elements
static void printArray(int[] arr) {
for (int num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
// Driver Code
public static void main(String[] args) {
// Input arrays
int[] a = {7, 4, 8, 0, 1};
int[] b = {9, 7, 2, 3, 6};
int[] result = maximizeArray(a, b);
printArray(result);
}
}
# Python program to maximize array elements
# using priority queue for efficient selection
import heapq
# Function to maximize array elements
def maximizeArray(a, b):
n = len(a)
# Max heap to store elements in
# decreasing order
pq = []
# Hash set to ensure unique elements
hash_set = set()
# Insert all elements from a and b
# into max heap
for i in range(n):
heapq.heappush(pq, -a[i])
heapq.heappush(pq, -b[i])
# Extract n largest unique elements
largest = []
while pq and len(largest) < n:
top = -heapq.heappop(pq)
if top not in hash_set:
hash_set.add(top)
largest.append(top)
result = []
# Store elements of b in result that
# are present in hash
for i in range(n):
if b[i] in hash_set:
result.append(b[i])
hash_set.remove(b[i])
# Store elements of a in result that
# are present in hash
for i in range(n):
if a[i] in hash_set:
result.append(a[i])
hash_set.remove(a[i])
return result
# Function to print array elements
def printArray(arr):
print(" ".join(map(str, arr)))
# Driver Code
if __name__ == "__main__":
# Input arrays
a = [7, 4, 8, 0, 1]
b = [9, 7, 2, 3, 6]
result = maximizeArray(a, b)
printArray(result)
// C# program to maximize array elements
// using priority queue for efficient selection
using System;
using System.Collections.Generic;
class GfG {
// Custom Priority Queue (Max Heap)
class PriorityQueue {
private List<int> data = new List<int>();
// Insert element in heap
public void Enqueue(int val) {
data.Add(val);
// Sort in descending order
data.Sort((x, y) => y.CompareTo(x));
}
// Remove and return the max element
public int Dequeue() {
int top = data[0];
data.RemoveAt(0);
return top;
}
// Get the number of elements in the heap
public int Count() {
return data.Count;
}
}
// Function to maximize array elements
static int[] maximizeArray(int[] a, int[] b) {
int n = a.Length;
// Max heap to store elements in
// decreasing order
PriorityQueue pq = new PriorityQueue();
// Hash set to ensure unique elements
HashSet<int> hash = new HashSet<int>();
// Insert all elements from a and b
// into max heap
for (int i = 0; i < n; i++) {
pq.Enqueue(a[i]);
pq.Enqueue(b[i]);
}
// Extract n largest unique elements
List<int> largest = new List<int>();
while (pq.Count() > 0 && largest.Count < n) {
int top = pq.Dequeue();
if (!hash.Contains(top)) {
hash.Add(top);
largest.Add(top);
}
}
int[] result = new int[n];
int k = 0;
// Store elements of b in result that
// are present in hash
for (int i = 0; i < n; i++) {
if (hash.Contains(b[i])) {
result[k++] = b[i];
hash.Remove(b[i]);
}
}
// Store elements of a in result that
// are present in hash
for (int i = 0; i < n; i++) {
if (hash.Contains(a[i])) {
result[k++] = a[i];
hash.Remove(a[i]);
}
}
return result;
}
// Function to print array elements
static void printArray(int[] arr) {
Console.WriteLine(string.Join(" ", arr));
}
// Driver Code
public static void Main() {
// Input arrays
int[] a = {7, 4, 8, 0, 1};
int[] b = {9, 7, 2, 3, 6};
int[] result = maximizeArray(a, b);
printArray(result);
}
}
// JavaScript program to maximize array elements
// using priority queue for efficient selection
class PriorityQueue {
constructor() {
this.data = [];
}
push(val) {
this.data.push(val);
this.data.sort((x, y) => y - x);
}
pop() {
return this.data.shift();
}
size() {
return this.data.length;
}
}
// Function to maximize array elements
function maximizeArray(a, b) {
let n = a.length;
// Max heap to store elements in
// decreasing order
let pq = new PriorityQueue();
// Hash set to ensure unique elements
let hash = new Set();
// Insert all elements from a and b
// into max heap
for (let i = 0; i < n; i++) {
pq.push(a[i]);
pq.push(b[i]);
}
// Extract n largest unique elements
let largest = [];
while (pq.size() > 0 && largest.length < n) {
let top = pq.pop();
if (!hash.has(top)) {
hash.add(top);
largest.push(top);
}
}
let result = [];
// Store elements of b in result that
// are present in hash
for (let i = 0; i < n; i++) {
if (hash.has(b[i])) {
result.push(b[i]);
hash.delete(b[i]);
}
}
// Store elements of a in result that
// are present in hash
for (let i = 0; i < n; i++) {
if (hash.has(a[i])) {
result.push(a[i]);
hash.delete(a[i]);
}
}
return result;
}
// Function to print array elements
function printArray(arr) {
console.log(arr.join(" "));
}
// Driver Code
let a = [7, 4, 8, 0, 1];
let b = [9, 7, 2, 3, 6];
let result = maximizeArray(a, b);
printArray(result);
Output
9 7 6 4 8
