# Queue Operations

• Last Updated : 24 Dec, 2021

Given N integers, the task is to insert those elements in the queue. Also, given M integers, the task is to find the frequency of each number in the Queue.

Examples:

Input:
N = 8
1 2 3 4 5 2 3 1  (N integers)
M = 5
1 3 2 9 10  (M integers)
Output:
2 2 2 -1 -1

Explanation:
After inserting 1, 2, 3, 4, 5, 2, 3, 1 into the queue,  frequency of 1 is 2, 3 is 2, 2 is 2, 9 is -1 and 10 is -1 (since, 9 and 10 is not there in the queue).

Input:
N = 5
5 2 2 4 5   (N integers)
M = 5
2 3 4 5 1   (M integers)
Output:
2 -1 1 2 -1

Approach: The given problem can be solved by using a simple queue. The idea is to insert N integers one by one into the queue and then check the frequency of M integers. Separate functions will be created to perform both operations. Follow the steps below to solve the problem.

• Create a queue and push all given integers into the queue.
• After pushing all the elements into the queue create another function for counting the frequency of given M elements one by one.
• Take a variable cntFrequency to keep track of frequency of current element.
• Pop all the elements from queue till its size and each time check if current element in queue is equal to element for which we are checking for frequency.
– if both are equal, increment cntFrequency by 1
– else, do nothing.
• Push the current element back to the queue so that for next case queue will not get disturbed.
• Print the frequency of each element found.

Below is the implementation of the above approach:

## Java

 `// Java Program to implement above approach` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Declaring Queue` `        ``Queue q = ``new` `LinkedList<>();` `        ``int` `N = ``8``;` `        ``int``[] a = ``new` `int``[] { ``1``, ``2``, ``3``, ``4``, ``5``, ``2``, ``3``, ``1` `};` `        ``int` `M = ``5``;` `        ``int``[] b = ``new` `int``[] { ``1``, ``3``, ``2``, ``9``, ``10` `};`   `        ``// Invoking object of Geeks class` `        ``Geeks obj = ``new` `Geeks();`   `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``// calling insert()` `            ``// to add elements in queue` `            ``obj.insert(q, a[i]);` `        ``}`   `        ``for` `(``int` `i = ``0``; i < M; i++) {` `            ``// calling findFrequency()` `            ``int` `f = obj.findFrequency(q, b[i]);` `            ``if` `(f != ``0``) {` `                ``// variable f` `                ``// will have final frequency` `                ``System.out.print(f + ``" "``);` `            ``}` `            ``else` `{` `                ``System.out.print(``"-1"` `                                 ``+ ``" "``);` `            ``}` `        ``}` `    ``}` `}`   `// Helper class Geeks to implement` `// insert() and findFrequency()` `class` `Geeks {`   `    ``// Function to insert` `    ``// element into the queue` `    ``static` `void` `insert(Queue q, ``int` `k)` `    ``{` `        ``// adding N integers into the Queue` `        ``q.add(k);` `    ``}`   `    ``// Function to find frequency of an element` `    ``// return the frequency of k` `    ``static` `int` `findFrequency(Queue q, ``int` `k)` `    ``{` `        ``// to count frequency of elements` `        ``int` `cntFrequency = ``0``;`   `        ``// storing size of queue in a variable` `        ``int` `size = q.size();`   `        ``// running loop until size becomes zero` `        ``while` `(size-- != ``0``) {`   `            ``// storing and deleting` `            ``// first element from queue` `            ``int` `x = q.poll();`   `            ``// comparing if it's equal to integer K` `            ``// that belongs to M` `            ``if` `(x == k) {` `                ``// increment count` `                ``cntFrequency++;` `            ``}` `            ``// add element back to queue because` `            ``// we also want N integers` `            ``q.add(x);` `        ``}` `        ``// return the count` `        ``return` `cntFrequency;` `    ``}` `}`

## Python3

 `# Python Program to implement above approach` `import` `collections`   `# Helper class Geeks to implement` `# insert() and findFrequency()` `class` `Geeks:`   `    ``# Function to insert` `    ``# element into the queue` `    ``def` `insert(``self``, q, k):` `      `  `        ``# adding N integers into the Queue` `        ``q.append(k)`   `    ``# Function to find frequency of an element` `    ``# return the frequency of k` `    ``def` `findFrequency(``self``, q, k):` `      `  `        ``# to count frequency of elements` `        ``cntFrequency ``=` `0`   `        ``# storing size of queue in a variable` `        ``size ``=` `len``(q)`   `        ``# running loop until size becomes zero` `        ``while` `(size):` `            ``size ``=` `size ``-` `1` `            `  `            ``# storing and deleting` `            ``# first element from queue` `            ``x ``=` `q.popleft()`   `            ``# comparing if it's equal to integer K` `            ``# that belongs to M` `            ``if` `(x ``=``=` `k):` `              `  `                ``# increment count` `                ``cntFrequency ``+``=` `1` `                `  `            ``# add element back to queue because` `            ``# we also want N integers` `            ``q.append(x)`   `        ``# return the count` `        ``return` `cntFrequency`   `# Declaring Queue` `q ``=` `collections.deque()` `N ``=` `8` `a ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``2``, ``3``, ``1``]` `M ``=` `5` `b ``=` `[``1``, ``3``, ``2``, ``9``, ``10``]`   `# Invoking object of Geeks class` `obj ``=` `Geeks()`   `for` `i ``in` `range``(N):`   `    ``# calling insert()` `    ``# to add elements in queue` `    ``obj.insert(q, a[i])`   `for` `i ``in` `range``(M):`   `    ``# calling findFrequency()` `    ``f ``=` `obj.findFrequency(q, b[i])` `    ``if` `(f !``=` `0``):` `      `  `        ``# variable f` `        ``# will have final frequency` `        ``print``(f, end``=``" "``)` `    ``else``:` `        ``print``(``"-1"``, end``=``" "``)` `print``(``" "``)`   `# This code is contributed by gfgking.`

## C#

 `// C# Program to implement above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG {` `  `  `  ``// Helper class Geeks to implement` `// insert() and findFrequency()` `public` `class` `Geeks {`   `    ``// Function to insert` `    ``// element into the queue` `   ``public` `void` `insert(Queue<``int``> q, ``int` `k)` `    ``{` `        ``// adding N integers into the Queue` `        ``q.Enqueue(k);` `    ``}`   `    ``// Function to find frequency of an element` `    ``// return the frequency of k` `    ``public` `int` `findFrequency(Queue<``int``> q, ``int` `k)` `    ``{` `        ``// to count frequency of elements` `        ``int` `cntFrequency = 0;`   `        ``// storing size of queue in a variable` `        ``int` `size = q.Count;`   `        ``// running loop until size becomes zero` `        ``while` `(size-- != 0) {`   `            ``// storing and deleting` `            ``// first element from queue` `            ``int` `x = q.Peek();` `            ``q.Dequeue();`   `            ``// comparing if it's equal to integer K` `            ``// that belongs to M` `            ``if` `(x == k) {` `                ``// increment count` `                ``cntFrequency++;` `            ``}` `            ``// add element back to queue because` `            ``// we also want N integers` `            ``q.Enqueue(x);` `        ``}` `        ``// return the count` `        ``return` `cntFrequency;` `    ``}` `}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `      `  `        ``// Declaring Queue` `        ``Queue<``int``> q = ``new` `Queue<``int``>();` `        ``int` `N = 8;` `        ``int``[] a = ``new` `int``[] { 1, 2, 3, 4, 5, 2, 3, 1 };` `        ``int` `M = 5;` `        ``int``[] b = ``new` `int``[] { 1, 3, 2, 9, 10 };`   `        ``// Invoking object of Geeks class` `        ``Geeks obj = ``new` `Geeks();`   `        ``for` `(``int` `i = 0; i < N; i++)` `        ``{` `          `  `            ``// calling insert()` `            ``// to add elements in queue` `            ``obj.insert(q, a[i]);` `        ``}`   `        ``for` `(``int` `i = 0; i < M; i++)` `        ``{` `          `  `            ``// calling findFrequency()` `            ``int` `f = obj.findFrequency(q, b[i]);` `            ``if` `(f != 0)` `            ``{` `              `  `                ``// variable f` `                ``// will have final frequency` `                ``Console.Write(f + ``" "``);` `            ``}` `            ``else` `{` `                ``Console.Write(``"-1"` `                                 ``+ ``" "``);` `            ``}` `        ``}` `    ``}` `}`   `// This code is contributed by SURENDRA_GANGWAR.`

Output

`2 2 2 -1 -1 `

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :