删除给定元素后找到最小的

给定一个整数数组，在删除给定元素后找到最小的数字。在重复元素的情况下，我们为包含要删除元素的数组中存在的每个实例删除一个实例（从原始数组中）。
例子：

Input : Array = {5, 12, 33, 4, 56, 12, 20} 
To Delete = {12, 4, 56, 5} 
Output : 12 
After deleting given elements, array becomes {33, 12, 20} and minimum element becomes 12. Note that there are two occurrences of 12 and we delete one of them. 
Input : Array = {1, 20, 3, 4, 10} 
To Delete = {1, 4, 10} 
Output : 3

方法 ：

• 将哈希映射中所有要从数组中删除的数字插入，以便我们可以在 O(1) 时间内检查数组中的元素是否也存在于 Delete-array 中。
• 将最小数 min 初始化为 INT_MAX。
• 遍历数组。检查该元素是否存在于哈希映射中。
• 如果存在，将其从哈希映射中删除，否则，如果不存在，则将其与 min 变量进行比较，如果元素的值小于 min 值，则更改其值。

C++

// C++ program to find the smallest number
// from the array after  n deletions
#include "climits"
#include "iostream"
#include "unordered_map"
using namespace std;
 
// Returns minimum element from arr[0..m-1] after deleting
// elements from del[0..n-1]
int findSmallestAfterDel(int arr[], int m, int del[], int n)
{
    // Hash Map of the numbers to be deleted
    unordered_map mp;
    for (int i = 0; i < n; ++i) {
 
        // Increment the count of del[i]
        mp[del[i]]++;
    }
 
    // Initializing the smallestElement
    int smallestElement = INT_MAX;
 
    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 compare it smallestElement
        else
            smallestElement = min(smallestElement, arr[i]);
    }
     
    return smallestElement;
}
 
int main()
{
    int array[] = { 5, 12, 33, 4, 56, 12, 20 };
    int m = sizeof(array) / sizeof(array[0]);
 
    int del[] = { 12, 4, 56, 5 };
    int n = sizeof(del) / sizeof(del[0]);
 
    cout << findSmallestAfterDel(array, m, del, n);
    return 0;
}

Java

// Java program to find the smallest number
// from the array after n deletions
import java.util.*;
 
class GFG
{
 
// Returns minimum element from arr[0..m-1]
// after deleting elements from del[0..n-1]
static int findSmallestAfterDel(int arr[], int m,
                                int del[], int n)
{
    // 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);
        }
    }
 
    // Initializing the smallestElement
    int smallestElement = Integer.MAX_VALUE;
 
    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 compare it smallestElement
        else
            smallestElement = Math.min(smallestElement,
                                               arr[i]);
    }
     
    return smallestElement;
}
 
// Driver Code
public static void main(String[] args)
{
    int array[] = { 5, 12, 33, 4, 56, 12, 20 };
    int m = array.length;
 
    int del[] = { 12, 4, 56, 5 };
    int n = del.length;
 
    System.out.println(findSmallestAfterDel(array, m,
                                            del, n));
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 program to find the smallest
# number from the array after n deletions
import math as mt
 
# Returns maximum element from arr[0..m-1]
# after deleting elements from del[0..n-1]
def findSmallestAfterDel(arr, m, dell, n):
 
    # 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
             
    # Initializing the SmallestElement
    SmallestElement = 10**9
 
    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 compare it SmallestElement
        else:
            SmallestElement = min(SmallestElement,
                                           arr[i])
     
    return SmallestElement
 
# Driver code
array = [5, 12, 33, 4, 56, 12, 20]
m = len(array)
 
dell = [12, 4, 56, 5]
n = len(dell)
 
print(findSmallestAfterDel(array, m, dell, n))
 
# This code is contributed
# by mohit kumar 29

C#

// C# program to find the smallest number
// from the array after n deletions
using System;
using System.Collections.Generic;
 
class GFG
{
 
// Returns minimum element from arr[0..m-1]
// after deleting elements from del[0..n-1]
static int findSmallestAfterDel(int []arr, int m,
                                int []del, int n)
{
    // Hash Map of the numbers to be deleted
    Dictionary mp = new Dictionary();
    for (int i = 0; i < n; ++i)
    {
 
        // Increment the count of del[i]
        if(mp.ContainsKey(del[i]))
        {
            mp[del[i]] = mp[del[i]] + 1;
        }
        else
        {
            mp.Add(del[i], 1);
        }
    }
 
    // Initializing the smallestElement
    int smallestElement = int.MaxValue;
    for (int i = 0; i < m; ++i)
    {
 
        // Search if the element is present
        if (mp.ContainsKey(arr[i]))
        {
 
            // Decrement its frequency
            mp[arr[i]] = mp[arr[i]] - 1;
 
            // If the frequency becomes 0,
            // erase it from the map
            if (mp[arr[i]] == 0)
                mp.Remove(arr[i]);
        }
 
        // Else compare it smallestElement
        else
            smallestElement = Math.Min(smallestElement,
                                               arr[i]);
    }
    return smallestElement;
}
 
// Driver Code
public static void Main(String[] args)
{
    int []array = { 5, 12, 33, 4, 56, 12, 20 };
    int m = array.Length;
 
    int []del = { 12, 4, 56, 5 };
    int n = del.Length;
 
    Console.WriteLine(findSmallestAfterDel(array, m,
                                           del, n));
}
}
 
// This code is contributed by Princi Singh

Javascript

 
// JavaScript program to find the smallest number
// from the array after n deletions
 
// Returns minimum element from arr[0..m-1]
// after deleting elements from del[0..n-1]
function findSmallestAfterDel(arr,m,del,n)
{
    // Hash Map of the numbers to be deleted
    let mp = new Map();
    for (let i = 0; i < n; ++i)
    {
   
        // Increment the count of del[i]
        if(mp.has(del[i]))
        {
            mp.set(del[i], mp.get(del[i]) + 1);
        }
        else
        {
            mp.set(del[i], 1);
        }
    }
   
    // Initializing the smallestElement
    let smallestElement = Number.MAX_VALUE;
   
    for (let i = 0; i < m; ++i)
    {
   
        // Search if the element is present
        if (mp.has(arr[i]))
        {
   
            // Decrement its frequency
            mp.set(arr[i], mp.get(arr[i]) - 1);
   
            // If the frequency becomes 0,
            // erase it from the map
            if (mp.get(arr[i]) == 0)
                mp.delete(arr[i]);
        }
   
        // Else compare it smallestElement
        else
            smallestElement = Math.min(smallestElement,
                                               arr[i]);
    }
       
    return smallestElement;
}
 
// Driver Code
let array=[5, 12, 33, 4, 56, 12, 20];
let m = array.length;
 
let del=[12, 4, 56, 5];
let n = del.length;
document.write(findSmallestAfterDel(array, m,
                                            del, n));
 
 
// This code is contributed by patel2127
 

输出：

12

时间复杂度– O(N)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。