# Find the k smallest numbers after deleting given elements

• Difficulty Level : Easy
• Last Updated : 07 Sep, 2022

Given an array of integers, find the k smallest numbers after deleting given elements. In case of repeating elements delete only one instance in the given array for every instance of element present in the array containing the elements to be deleted.

Assume that there are at least k elements left in the array after making n deletions.

Examples:

Input : array[] = { 5, 12, 33, 4, 56, 12, 20 }, del[] = { 12, 56, 5 }, k = 3
Output : 4 12 20
Explanation : After deletions { 33, 4, 12, 20 } will be left. Print top 3 smallest elements from it.

Approach :

• Insert all the numbers in the hash map which are to be deleted from the array, so that we can check if the element in the array is also present in the Delete-array in O(1) time.
• Traverse through the array. Check if the element is present in the hash map.
• If present, erase it from the hash map.
• Else, insert it into a Min heap.
• After inserting all the elements excluding the ones which are to be deleted, Pop-out k elements from the Min heap.

Implementation:

## C++

 `#include "iostream"``#include "queue"``#include "unordered_map"``#include "vector"``using` `namespace` `std;` `// Find k minimum element from arr[0..m-1] after deleting``// elements from del[0..n-1]``void` `findElementsAfterDel(``int` `arr[], ``int` `m, ``int` `del[],``                          ``int` `n, ``int` `k)``{``    ``// Hash Map of the numbers to be deleted``    ``unordered_map<``int``, ``int``> mp;``    ``for` `(``int` `i = 0; i < n; ++i) {` `        ``// Increment the count of del[i]``        ``mp[del[i]]++;``    ``}` `    ``priority_queue<``int``, vector<``int``>, greater<``int``> > heap;` `    ``for` `(``int` `i = 0; i < m; ++i) {` `        ``// Search if the element is present``        ``if` `(mp.find(arr[i]) != mp.end()) {` `            ``// Decrement its frequency``            ``mp[arr[i]]--;` `            ``// If the frequency becomes 0,``            ``// erase it from the map``            ``if` `(mp[arr[i]] == 0)``                ``mp.erase(arr[i]);``        ``}` `        ``// Else push it in the min heap``        ``else``            ``heap.push(arr[i]);``    ``}` `    ``// Print top k elements in the min heap``    ``for` `(``int` `i = 0; i < k; ++i) {``        ``cout << heap.top() << ``" "``;` `        ``// Pop the top element``        ``heap.pop();``    ``}``}` `int` `main()``{``    ``int` `array[] = { 5, 12, 33, 4, 56, 12, 20 };``    ``int` `m = ``sizeof``(array) / ``sizeof``(array[0]);` `    ``int` `del[] = { 12, 56, 5 };``    ``int` `n = ``sizeof``(del) / ``sizeof``(del[0]);` `    ``int` `k = 3;` `    ``findElementsAfterDel(array, m, del, n, k);``    ``return` `0;``}`

## Java

 `// Java program to find the k maximum ``// number from the array after n deletions``import` `java.util.*;``public` `class` `GFG``{``  ` `    ``// Find k minimum element from arr[0..m-1] after deleting``    ``// elements from del[0..n-1]``    ``static` `void` `findElementsAfterDel(``int``[] arr,``                                     ``int` `m, ``int``[] del,``                                     ``int` `n, ``int` `k)``    ``{``       ` `        ``// Hash Map of the numbers to be deleted``        ``HashMap mp = ``new` `HashMap<>();``        ``for` `(``int` `i = ``0``; i < n; ++i)``        ``{``       ` `            ``// Increment the count of del[i]``            ``if``(mp.containsKey(del[i]))``            ``{``                ``mp.put(del[i], mp.get(del[i])+``1``);``            ``}``            ``else``{``                ``mp.put(del[i], ``1``);``            ``}``        ``}``       ` `        ``Vector heap = ``new` `Vector();``        ``for` `(``int` `i = ``0``; i < m; ++i)``        ``{``       ` `            ``// Search if the element is present``            ``if` `(mp.containsKey(arr[i]))``            ``{``       ` `                ``// Decrement its frequency``                ``mp.put(arr[i], mp.get(arr[i]) - ``1``);``       ` `                ``// If the frequency becomes 0,``                ``// erase it from the map``                ``if` `(mp.get(arr[i]) == ``0``)``                    ``mp.remove(arr[i]);``            ``}``       ` `            ``// Else push it in the min heap``            ``else``                ``heap.add(arr[i]);``        ``}``         ` `        ``Collections.sort(heap); ``       ` `        ``// Print top k elements in the min heap``        ``for` `(``int` `i = ``0``; i < k; ++i)``        ``{``            ``System.out.print(heap.get(``0``) + ``" "``);``       ` `            ``// Pop the top element``            ``heap.remove(``0``);``        ``}``    ``}``    ` `  ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] array = { ``5``, ``12``, ``33``, ``4``, ``56``, ``12``, ``20` `};``        ``int` `m = array.length;``       ` `        ``int``[] del = { ``12``, ``56``, ``5` `};``        ``int` `n = del.length;``       ` `        ``int` `k = ``3``;``       ` `        ``findElementsAfterDel(array, m, del, n, k);``    ``}``}` `// This code is contributed by divvyeshrabadiya07.`

## Python3

 `# Python3 program to find the k maximum``# number from the array after n deletions``import` `math as mt``import` `heapq``# Find k maximum element from arr[0..m-1]``# after deleting elements from del[0..n-1]`  `def` `findElementsAfterDel(arr, m, dell, n, k):``    ``# Hash Map of the numbers to be deleted``    ``mp ``=` `dict``()``    ``for` `i ``in` `range``(n):``        ``# Increment the count of del[i]``        ``if` `dell[i] ``in` `mp.keys():``            ``mp[dell[i]] ``+``=` `1``        ``else``:``            ``mp[dell[i]] ``=` `1``    ``heap ``=` `[]``    ``for` `i ``in` `range``(m):``        ``# Search if the element is present``        ``if` `(arr[i] ``in` `mp.keys()):``            ``# Decrement its frequency``            ``mp[arr[i]] ``-``=` `1``            ``# If the frequency becomes 0,``            ``# erase it from the map``            ``if` `(mp[arr[i]] ``=``=` `0``):``                ``mp.pop(arr[i])``        ``# else push it to heap``        ``else``:``            ``heap.append(arr[i])``    ``# creating min heap and heapifying it``    ``heapq.heapify(heap)``    ``# retuurning nsmallest elements from the min heap.``    ``return` `heapq.nsmallest(k, heap)`  `# Driver code``array ``=` `[``5``, ``12``, ``33``, ``4``, ``56``, ``12``, ``20``]``m ``=` `len``(array)` `dell ``=` `[``12``, ``56``, ``5``]``n ``=` `len``(dell)``k ``=` `3``print``(``*``findElementsAfterDel(array, m, dell, n, k))``'''Code is written by RAJAT KUMAR'''`

## C#

 `// C# program to find the k maximum ``// number from the array after n deletions``using` `System;``using` `System.Collections.Generic;``class` `GFG``{`` ` `    ``// Find k minimum element from arr[0..m-1] after deleting``    ``// elements from del[0..n-1]``    ``static` `void` `findElementsAfterDel(``int``[] arr, ``int` `m, ``int``[] del,``                              ``int` `n, ``int` `k)``    ``{``      ` `        ``// Hash Map of the numbers to be deleted``        ``Dictionary<``int``, ``int``> mp = ``new` `Dictionary<``int``, ``int``>();``        ``for` `(``int` `i = 0; i < n; ++i)``        ``{``      ` `            ``// Increment the count of del[i]``            ``if``(mp.ContainsKey(del[i]))``            ``{``                ``mp[del[i]]++;``            ``}``            ``else``{``                ``mp[del[i]] = 1;``            ``}``        ``}``      ` `        ``List<``int``> heap = ``new` `List<``int``>();``        ``for` `(``int` `i = 0; i < m; ++i)``        ``{``      ` `            ``// Search if the element is present``            ``if` `(mp.ContainsKey(arr[i]))``            ``{``      ` `                ``// Decrement its frequency``                ``mp[arr[i]]--;``      ` `                ``// If the frequency becomes 0,``                ``// erase it from the map``                ``if` `(mp[arr[i]] == 0)``                    ``mp.Remove(arr[i]);``            ``}``      ` `            ``// Else push it in the min heap``            ``else``                ``heap.Add(arr[i]);``        ``}``        ` `        ``heap.Sort();``      ` `        ``// Print top k elements in the min heap``        ``for` `(``int` `i = 0; i < k; ++i)``        ``{``            ``Console.Write(heap[0] + ``" "``);``      ` `            ``// Pop the top element``            ``heap.RemoveAt(0);``        ``}``    ``}  ``    ` `  ``// Driver code``  ``static` `void` `Main()``  ``{``    ``int``[] array = { 5, 12, 33, 4, 56, 12, 20 };``    ``int` `m = array.Length;``  ` `    ``int``[] del = { 12, 56, 5 };``    ``int` `n = del.Length;``  ` `    ``int` `k = 3;``  ` `    ``findElementsAfterDel(array, m, del, n, k);``  ``}``}` `// This code is contributed by divyesh072019.`

## Javascript

 ``

Output

`4 12 20 `

Complexity Analysis:

• Time Complexity: O(M*log(M)), since inserting in a priority queue is logarithmic operation and we are doing it M times in worst case where M is the array size.
• Auxiliary Space: O(M + N), where M and N represents the size of the given two arrays.

My Personal Notes arrow_drop_up