Open In App

# Most frequent word in an array of strings

Given an array of words arr[],  The task is to find the most occurring word in arr[].

Examples:

Input : arr[] = {“geeks”, “for”, “geeks”, “a”,
“portal”, “to”, “learn”, “can”,
“be”, “computer”, “science”,
“zoom”, “yup”, “fire”, “in”,
“be”, “data”, “geeks”}
Output : geeks
Explanation : “geeks” is the most frequent word in the given array occurring 3 times

Input:  arr[] = {“hello”, “world”}
Output: world

## Most frequent word in an array of strings By Using Nested Loops:

The idea is to run a loop for each word and count the frequency of the word using a nested loop

Follow the below steps to Implement the idea:

• Traverse a loop for each word in the given array
• Run a nested loop and count the frequency of the word
• Initialize res = “” and freq = 0, to store the resulting string and the frequency of the string.
• If the frequency of the word is greater than the freq
• Update freq to the frequency of current word.
• Update res to current word.
• Print res and freq as the final answer.

Below is the Implementation of the above approach.

## C++

 `// CPP code to find most frequent word in``// an array of strings``#include ``using` `namespace` `std;` `void` `mostFrequentWord(string arr[], ``int` `n)``{``    ``// freq to store the freq of the most occurring variable``    ``int` `freq = 0;``    ``// res to store the most occurring string in the array of``    ``// strings``    ``string res;` `    ``// running nested for loops to find the most occurring``    ``// word in the array of strings``    ``for` `(``int` `i = 0; i < n; i++) {``        ``int` `count = 0;``        ``for` `(``int` `j = i + 1; j < n; j++) {``            ``if` `(arr[j] == arr[i]) {``                ``count++;``            ``}``        ``}``        ``// updating our max freq of occurred string in the``        ``// array of strings``        ``if` `(count >= freq) {``            ``res = arr[i];``            ``freq = count;``        ``}``    ``}` `    ``cout << ``"The word that occurs most is : "` `<< res``         ``<< endl;``    ``cout << ``"No of times: "` `<< freq << endl;``}` `// Driver code``int` `main()``{``    ``// given set of keys``    ``string arr[]``        ``= { ``"geeks"``,   ``"for"``,   ``"geeks"``, ``"a"``,    ``"portal"``,``            ``"to"``,      ``"learn"``, ``"can"``,   ``"be"``,   ``"computer"``,``            ``"science"``, ``"zoom"``,  ``"yup"``,   ``"fire"``, ``"in"``,``            ``"be"``,      ``"data"``,  ``"geeks"` `};``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``mostFrequentWord(arr, n);` `    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;` `class` `GFG``{``  ``static` `void` `mostFrequentWord(String arr[], ``int` `n)``  ``{` `    ``// freq to store the freq of the most occurring variable``    ``int` `freq = ``0``;` `    ``// res to store the most occurring string in the array of``    ``// strings``    ``String res = ``""``;` `    ``// running nested for loops to find the most occurring``    ``// word in the array of strings``    ``for` `(``int` `i = ``0``; i < n; i++) {``      ``int` `count = ``0``;``      ``for` `(``int` `j = i + ``1``; j < n; j++) {``        ``if` `(arr[j].equals(arr[i])) {``          ``count++;``        ``}``      ``}` `      ``// updating our max freq of occurred string in the``      ``// array of strings``      ``if` `(count >= freq) {``        ``res = arr[i];``        ``freq = count;``      ``}``    ``}` `    ``System.out.println(``"The word that occurs most is : "` `+ res);``    ``System.out.println(``"No of times: "` `+ freq);``  ``}` `  ``public` `static` `void` `main (String[] args)``  ``{` `    ``// given set of keys``    ``String arr[] = { ``"geeks"``,   ``"for"``,   ``"geeks"``, ``"a"``,    ``"portal"``,``                    ``"to"``,      ``"learn"``, ``"can"``,   ``"be"``,   ``"computer"``,``                    ``"science"``, ``"zoom"``,  ``"yup"``,   ``"fire"``, ``"in"``,``                    ``"be"``,      ``"data"``,  ``"geeks"` `};``    ``int` `n = arr.length;` `    ``mostFrequentWord(arr, n);``  ``}``}` `// This code is contributed by aadityaburujwale.`

## Python3

 `def` `mostFrequentWord(arr, n):``  ` `    ``# freq to store the freq of the most occurring variable``    ``freq ``=` `0``    ` `    ``# res to store the most occurring string in the array of strings``    ``res ``=` `""` `    ``# running nested for loops to find the most occurring``    ``# word in the array of strings``    ``for` `i ``in` `range``(``0``, n, ``1``):``        ``count ``=` `0``        ``for` `j ``in` `range``(i ``+` `1``, n, ``1``):``            ``if` `arr[j] ``=``=` `arr[i]:``                ``count ``+``=` `1` `        ``# updating our max freq of occurred string in the``        ``# array of strings``        ``if` `count >``=` `freq:``            ``res ``=` `arr[i]``            ``freq ``=` `count` `    ``print``(``"The word that occurs most is : "` `+` `str``(res))``    ``print``(``"No of times: "` `+` `str``(freq))` `# Driver code` `# given set of keys``arr ``=` `[ ``"geeks"``, ``"for"``, ``"geeks"``, ``"a"``, ``"portal"``, ``"to"``, ``"learn"``, ``"can"``, ``"be"``, ``"computer"``, ``"science"``, ``"zoom"``, ``"yup"``, ``"fire"``, ``"in"``, ``"be"``, ``"data"``, ``"geeks"``,]``n ``=` `len``(arr)` `# function call``mostFrequentWord(arr, n)` `# This code is contributed by ajaymakavana.`

## C#

 `using` `System;``class` `GFG {` `  ``// Function to find minimum operation``  ``// to convert string into palindrome``  ``static` `void` `mostFrequentWord(``string``[] arr, ``int` `n)``  ``{``    ``// freq to store the freq of the most occurring``    ``// variable``    ``int` `freq = 0;``    ``// res to store the most occurring string in the``    ``// array of strings``    ``string` `res = ``""``;` `    ``// running nested for loops to find the most``    ``// occurring word in the array of strings``    ``for` `(``int` `i = 0; i < n; i++) {``      ``int` `count = 0;``      ``for` `(``int` `j = i + 1; j < n; j++) {``        ``if` `(arr[j] == arr[i]) {``          ``count++;``        ``}``      ``}``      ``// updating our max freq of occurred string in``      ``// the array of strings``      ``if` `(count >= freq) {``        ``res = arr[i];``        ``freq = count;``      ``}``    ``}` `    ``Console.WriteLine(``"The word that occurs most is : "``                      ``+ res);` `    ``Console.WriteLine(``"No of times: "` `+ freq);``  ``}``  ` `  ``// Driver Code``  ``public` `static` `void` `Main()``  ``{``    ``string``[] arr``      ``= { ``"geeks"``,  ``"for"``,      ``"geeks"``,   ``"a"``,``         ``"portal"``, ``"to"``,       ``"learn"``,   ``"can"``,``         ``"be"``,     ``"computer"``, ``"science"``, ``"zoom"``,``         ``"yup"``,    ``"fire"``,     ``"in"``,      ``"be"``,``         ``"data"``,   ``"geeks"` `};``    ``int` `n = 18;``    ``// Function Call``    ``mostFrequentWord(arr, n);``  ``}``}` `// This code is contributed by garg28harsh.`

## Javascript

 `function` `mostFrequentWord(arr, n){``    ``// freq to store the freq of the most occurring variable``    ``let freq = 0;``    ` `    ``// res to store the most occurring string in the array of``    ``// strings``    ``let res = ``""``;``    ` `    ``// running nested for loops to find the most occurring``    ``// word in the array of strings``    ``for``(let i=0;i=freq){``            ``res = arr[i];``            ``freq = count;``        ``}``    ``}``    ` `    ``console.log(``"The word that occurs most is : "` `+ res + ``"
"``);``    ``console.log(``"No of times: "` `+ freq);``}` `// given set of keys``let arr = [ ``"geeks"``, ``"for"``, ``"geeks"``, ``"a"``, ``"portal"``, ``"to"``, ``"learn"``, ``"can"``, ``"be"``, ``"computer"``, ``"science"``, ``"zoom"``, ``"yup"``, ``"fire"``, ``"in"``, ``"be"``, ``"data"``, ``"geeks"` `];``let n = arr.length;` `mostFrequentWord(arr, n);`` ` `// This code is contributed by lokesh.`

Output

```The word that occurs most is : geeks
No of times: 2```

Time Complexity: O(N*N), when N is the size of the given array.
Auxiliary Space: O(1)

## Most frequent word in an array of strings By Using 2 Hashmaps:

The Idea is to maintain 2 Hashmaps, one to record the first occurrence of the word and second to count the frequency of the word.

Follow the below steps to Implement the idea:

• Initialize two Hashmaps freq and occurrence.
• Initialize result = “”, max =  0, and k = 1.
• Traverse a loop from 1 till N
• If the current word exist in the occurrence hashmap:
• then continue.
• Else update occurrence[arr[i]] = k
• Increment k by 1
• Traverse another loop from 1 till N
• Increment the count of the current element in freq by 1
• If max <= freq[arr[i]]
• if max < freq[arr[i]]
• Update max = freq[arr[i]]
• Update result = arr[i]
• Else
• if occurrence[result] < occurrence[freq[arr[i]]]
• Update max = freq[arr[i]]
• Update result = arr[i]
• Return result.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `class` `Solution {``public``:``    ``// Function to find most frequent word``    ``// in an array of strings.``    ``string mostFrequentWord(string arr[], ``int` `n)``    ``{``        ``unordered_map freq;``        ``unordered_map occurrence;``        ``int` `max = 0;``        ``string result;``        ``int` `k = 1;` `        ``for` `(``int` `i = 0; i < n; i++) {``            ``if` `(occurrence.count(arr[i]) > 0) {``                ``continue``;``            ``}` `            ``occurrence[arr[i]] = k++;``        ``}` `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``freq[arr[i]]++;` `            ``if` `(max <= freq[arr[i]]) {` `                ``if` `(max < freq[arr[i]]) {``                    ``max = freq[arr[i]];``                    ``result = arr[i];``                ``}``                ``else` `{``                    ``if` `(occurrence[result]``                        ``< occurrence[arr[i]]) {``                        ``max = freq[arr[i]];``                        ``result = arr[i];``                    ``}``                ``}``            ``}``        ``}` `        ``return` `result;``    ``}``};` `int` `main()``{` `    ``string arr[]``        ``= { ``"geeks"``,   ``"for"``,   ``"geeks"``, ``"a"``,    ``"portal"``,``            ``"to"``,      ``"learn"``, ``"can"``,   ``"be"``,   ``"computer"``,``            ``"science"``, ``"zoom"``,  ``"yup"``,   ``"fire"``, ``"in"``,``            ``"be"``,      ``"data"``,  ``"geeks"` `};``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``Solution obj;``    ``cout << obj.mostFrequentWord(arr, n) << endl;` `    ``return` `0;``}`

## Java

 `import` `java.util.*;``class` `GFG {` `    ``// User function template for Java` `    ``// Function to find most frequent word in an array of``    ``// Strings.``    ``String mostFrequentWord(String arr[], ``int` `n)``    ``{``        ``HashMap freq = ``new` `HashMap<>();``        ``HashMap occurrence``            ``= ``new` `HashMap<>();``        ``int` `max = ``0``;``        ``String result = ``""``;``        ``int` `k = ``1``;` `        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``if` `(occurrence.containsKey(arr[i])) {``                ``continue``;``            ``}` `            ``occurrence.put(arr[i], k);``            ``k++;``        ``}` `        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``if` `(freq.containsKey(arr[i])) {``                ``freq.put(arr[i], freq.get(arr[i]) + ``1``);``            ``}``            ``else``                ``freq.put(arr[i], +``1``);` `            ``if` `(max <= freq.get(arr[i])) {` `                ``if` `(max < freq.get(arr[i])) {``                    ``max = freq.get(arr[i]);``                    ``result = arr[i];``                ``}``                ``else` `{``                    ``if` `(occurrence.get(result)``                        ``< occurrence.get(arr[i])) {``                        ``max = freq.get(arr[i]);``                        ``result = arr[i];``                    ``}``                ``}``            ``}``        ``}` `        ``return` `result;``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{` `        ``String arr[]``            ``= { ``"geeks"``,  ``"for"``,      ``"geeks"``,   ``"a"``,``                ``"portal"``, ``"to"``,       ``"learn"``,   ``"can"``,``                ``"be"``,     ``"computer"``, ``"science"``, ``"zoom"``,``                ``"yup"``,    ``"fire"``,     ``"in"``,      ``"be"``,``                ``"data"``,   ``"geeks"` `};``        ``int` `n = arr.length;` `        ``GFG obj = ``new` `GFG();``        ``System.out.print(obj.mostFrequentWord(arr, n)``                         ``+ ``"\n"``);``    ``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Function to find most frequent word``# in an array of strings.``def` `mostFrequentWord(arr, n):``    ``freq ``=` `dict``()``    ``occurrence ``=` `dict``()``    ``max` `=` `0``    ``result ``=` `""``    ``k ``=` `1` `    ``for` `i ``in` `range``(``0``, n):``        ``if` `arr[i] ``in` `occurrence.keys():``            ``continue` `        ``occurrence[arr[i]] ``=` `k``        ``k ``+``=` `1` `    ``for` `i ``in` `range``(``0``, n):``        ``if` `arr[i] ``in` `freq.keys():``            ``freq[arr[i]] ``+``=` `1``        ``else``:``            ``freq[arr[i]] ``=` `1` `        ``if` `max` `<``=` `freq[arr[i]]:` `            ``if` `max` `< freq[arr[i]]:``                ``max` `=` `freq[arr[i]]``                ``result ``=` `arr[i]``            ``else``:``                ``if` `occurrence[result] < occurrence[arr[i]]:``                    ``max` `=` `freq[arr[i]]``                    ``result ``=` `arr[i]` `    ``return` `result`  `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``'geeks'``, ``'for'``, ``'geeks'``, ``'a'``, ``'portal'``, ``'to'``, ``'learn'``, ``'can'``, ``'be'``,``           ``'computer'``, ``'science'``, ``'zoom'``, ``'yup'``, ``'fire'``, ``'in'``, ``'be'``, ``'data'``, ``'geeks'``]``    ``n ``=` `len``(arr)` `    ``print``(mostFrequentWord(arr, n), end``=``'')``    ``print``(``"\n"``, end``=``'')` `# This code is contributed by Aarti_Rathi`

## C#

 `// C# Program for the above approach` `using` `System;``using` `System.Collections;``using` `System.Collections.Generic;` `class` `Solution {` `    ``// Function to find most frequent word``    ``// in an array of strings.``    ``static` `string` `mostFrequentWord(``string``[] arr, ``int` `n)``    ``{``        ``Dictionary<``string``, ``int``> freq``            ``= ``new` `Dictionary<``string``, ``int``>();` `        ``Dictionary<``string``, ``int``> occurrence``            ``= ``new` `Dictionary<``string``, ``int``>();` `        ``int` `max = 0;``        ``string` `result = ``""``;``        ``int` `k = 1;` `        ``for` `(``int` `i = 0; i < n; i++) {``            ``if` `(occurrence.ContainsKey(arr[i])) {``                ``continue``;``            ``}``            ``occurrence[arr[i]] = k;``            ``k++;``        ``}` `        ``for` `(``int` `i = 0; i < n; i++) {``            ``if` `(freq.ContainsKey(arr[i])) {``                ``freq[arr[i]] = freq[arr[i]] + 1;``            ``}``            ``else` `{``                ``freq.Add(arr[i], 1);``            ``}` `            ``if` `(max <= freq[arr[i]]) {` `                ``if` `(max < freq[arr[i]]) {``                    ``max = freq[arr[i]];``                    ``result = arr[i];``                ``}``                ``else` `{``                    ``if` `(occurrence[result]``                        ``< occurrence[arr[i]]) {``                        ``max = freq[arr[i]];``                        ``result = arr[i];``                    ``}``                ``}``            ``}``        ``}` `        ``return` `result;``    ``}` `    ``public` `static` `void` `Main()``    ``{` `        ``string``[] arr``            ``= { ``"geeks"``,  ``"for"``,      ``"geeks"``,   ``"a"``,``                ``"portal"``, ``"to"``,       ``"learn"``,   ``"can"``,``                ``"be"``,     ``"computer"``, ``"science"``, ``"zoom"``,``                ``"yup"``,    ``"fire"``,     ``"in"``,      ``"be"``,``                ``"data"``,   ``"geeks"` `};``        ``int` `n = arr.Length;` `        ``Console.Write(mostFrequentWord(arr, n));``    ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 `    ``// Function to find most frequent word``    ``// in an array of strings.``    ``function` `mostFrequentWord(arr, n)``    ``{``       ` `        ``const freq = ``new` `Map();``        ``const occurrence = ``new` `Map();``        ``let max = 0;``        ``let result;``        ``let  k = 1;` `        ``for` `(let i = 0; i < n; i++) {``            ``if` `(occurrence.has(arr[i])== ``true` `) {``                ``continue``;``            ``}` `            ``occurrence.set(arr[i],k),k++;``        ``}` `        ``for` `(let i = 0; i < n; i++) {` `            ``// freq[arr[i]]++;``            ``let x=0;``            ``if``(freq.has(arr[i])==``true``)``                ``x= freq.get(arr[i]);``            ``freq.set(arr[i],x+1);``            ``if` `(max <= freq.get(arr[i])) {` `                ``if` `(max < freq.get(arr[i])) {``                    ``max = freq.get(arr[i]);``                    ``result = arr[i];``                ``}``                ``else` `{``                    ``if` `(occurrence.get(result)``                        ``< occurrence.get(arr[i])) {``                        ``max = freq.get(arr[i]);``                        ``result = arr[i];``                    ``}``                ``}``            ``}``        ``}` `        ``return` `result;``    ``}` `    ``let arr``        ``= [``"geeks"``,   ``"for"``,   ``"geeks"``, ``"a"``,    ``"portal"``,``            ``"to"``,      ``"learn"``, ``"can"``,   ``"be"``,   ``"computer"``,``            ``"science"``, ``"zoom"``,  ``"yup"``,   ``"fire"``, ``"in"``,``            ``"be"``,      ``"data"``,  ``"geeks"` `];``    ``let n = arr.length;` `    ``console.log(mostFrequentWord(arr, n));` `// This code is contributed by garg28harsh.`

Output

`geeks`

Time complexity: O(N), where N is the size of the given array.
Auxiliary Space: O(N)

## Most frequent word in an array of strings By Using single Hashmap:

The idea is to use a Hashmap to store the frequency of the words and find the word with the maximum frequency from the hashmap.

Follow the below steps to Implement the idea:

• Initialize a HashMap to store the frequency of the words.
• Traverse a loop from 1 till N
• Increment the count of current word in the Hashmap.
• Initialize key = “” and value = 0
• Traverse the Hashmap
• If the frequency of the current word is greater than value
• Update value to frequency of current character
• Update key as the current word
• return key.

Below is the implementation of the above approach.

## C++

 `// c++ implementation``// Function returns word with highest frequency` `#include ``using` `namespace` `std;` `// Function returns word with highest frequency``string findWord(vector arr)``{``    ``// Create HashMap to store word and it's frequency``    ``unordered_map hs;``    ``// Iterate through array of words``    ``for` `(``int` `i = 0; i < arr.size(); i++) {``        ``hs[arr[i]]++;``    ``}` `    ``string key = ``""``;``    ``int` `value = 0;``    ``for` `(``auto` `me : hs) {``        ``// Check for word having highest frequency``        ``if` `(me.second > value) {``            ``value = me.second;``            ``key = me.first;``        ``}``    ``}``    ``// Return word having highest frequency``    ``return` `key;``}` `int` `main()``{``    ``vector arr{ ``"geeks"``,    ``"for"``,     ``"geeks"``,``                        ``"a"``,        ``"portal"``,  ``"to"``,``                        ``"learn"``,    ``"can"``,     ``"be"``,``                        ``"computer"``, ``"science"``, ``"zoom"``,``                        ``"yup"``,      ``"fire"``,    ``"in"``,``                        ``"be"``,       ``"data"``,    ``"geeks"` `};``    ``string sol = findWord(arr);``    ``// Print word having highest frequency``    ``cout << sol << endl;``}` `// This code is contributed by Aarti_Rathi`

## Java

 `// Java implementation``import` `java.util.*;` `class` `GKG {` `    ``// Function returns word with highest frequency``    ``static` `String findWord(String[] arr)``    ``{` `        ``// Create HashMap to store word and it's frequency``        ``HashMap hs``            ``= ``new` `HashMap();` `        ``// Iterate through array of words``        ``for` `(``int` `i = ``0``; i < arr.length; i++) {``            ``// If word already exist in HashMap then``            ``// increase it's count by 1``            ``if` `(hs.containsKey(arr[i])) {``                ``hs.put(arr[i], hs.get(arr[i]) + ``1``);``            ``}``            ``// Otherwise add word to HashMap``            ``else` `{``                ``hs.put(arr[i], ``1``);``            ``}``        ``}` `        ``// Create set to iterate over HashMap``        ``Set > set``            ``= hs.entrySet();``        ``String key = ``""``;``        ``int` `value = ``0``;` `        ``for` `(Map.Entry me : set) {``            ``// Check for word having highest frequency``            ``if` `(me.getValue() > value) {``                ``value = me.getValue();``                ``key = me.getKey();``            ``}``        ``}` `        ``// Return word having highest frequency``        ``return` `key;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String arr[]``            ``= { ``"geeks"``,  ``"for"``,      ``"geeks"``,   ``"a"``,``                ``"portal"``, ``"to"``,       ``"learn"``,   ``"can"``,``                ``"be"``,     ``"computer"``, ``"science"``, ``"zoom"``,``                ``"yup"``,    ``"fire"``,     ``"in"``,      ``"be"``,``                ``"data"``,   ``"geeks"` `};``        ``String sol = findWord(arr);` `        ``// Print word having highest frequency``        ``System.out.println(sol);``    ``}``}` `// This code is contributed by Divyank Sheth`

## Python3

 `# Python implementation` `# Function returns word with highest frequency``def` `findWord(arr):``  ` `    ``# Create HashMap to store word and it's frequency``    ``hs ``=` `{}` `    ``# Iterate through array of words``    ``for` `i ``in` `arr:``        ``if``(i ``in` `hs):``            ``hs[i] ``+``=` `1``        ``else``:``            ``hs[i] ``=` `1``    ``key ``=` `""``    ``value ``=` `0``    ``for` `i ``in` `hs:``      ` `        ``# Check for word having highest frequency``        ``if``(hs[i] > value):``            ``value ``=` `hs[i]``            ``key ``=` `i` `    ``# Return word having highest frequency``    ``return` `key` `if` `__name__ ``=``=` `"__main__"``:``    ``arr ``=` `[``"geeks"``,``"for"``,``"geeks"``,``"a"``,``"portal"``, ``"to"``,``"learn"``,``"can"``,``"be"``,``"computer"``,``"science"``,``"zoom"``,``"yup"``,``"fire"``,``"in"``,``"be"``,``"data"``,``"geeks"``]``    ``sol ``=` `findWord(arr)``    ` `    ``# Print word having highest frequency``    ``print``(sol)``    ` `    ``# This code is contributed by ajaymakvana`

## C#

 `// C# implementation``using` `System;``using` `System.Collections.Generic;` `class` `GFG {` `    ``// Function returns word with highest frequency``    ``static` `String findWord(String[] arr)``    ``{` `        ``// Create Dictionary to store word``        ``// and it's frequency``        ``Dictionary hs``            ``= ``new` `Dictionary();` `        ``// Iterate through array of words``        ``for` `(``int` `i = 0; i < arr.Length; i++) {``            ``// If word already exist in Dictionary``            ``// then increase it's count by 1``            ``if` `(hs.ContainsKey(arr[i])) {``                ``hs[arr[i]] = hs[arr[i]] + 1;``            ``}` `            ``// Otherwise add word to Dictionary``            ``else` `{``                ``hs.Add(arr[i], 1);``            ``}``        ``}` `        ``// Create set to iterate over Dictionary``        ``String key = ``""``;``        ``int` `value = 0;` `        ``foreach``(KeyValuePair me ``in` `hs)``        ``{``            ``// Check for word having highest frequency``            ``if` `(me.Value > value) {``                ``value = me.Value;``                ``key = me.Key;``            ``}``        ``}` `        ``// Return word having highest frequency``        ``return` `key;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``String[] arr``            ``= { ``"geeks"``,  ``"for"``,      ``"geeks"``,   ``"a"``,``                ``"portal"``, ``"to"``,       ``"learn"``,   ``"can"``,``                ``"be"``,     ``"computer"``, ``"science"``, ``"zoom"``,``                ``"yup"``,    ``"fire"``,     ``"in"``,      ``"be"``,``                ``"data"``,   ``"geeks"` `};``        ``String sol = findWord(arr);` `        ``// Print word having highest frequency``        ``Console.WriteLine(sol);``    ``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

`geeks`

Time Complexity: O(N), where N is the size of the given array.
Auxiliary Space: O(N)

## Most frequent word in an array of strings By Using  Trie data structure:

The Idea is to store the count of each element and a string variable to keep track of the most occurring element in the array.

Follow the below steps to Implement the idea:

• Initialize a Trie root.
• Traverse the words in the given array
• Insert the word in Trie
• Increment the count of current word by 1
• If the maxCount < count of current word
• Update maxCount to current word count.
• Update maxFrequentString as the current word.
• Print maxFrequentString and maxCount.

Below is the implementation of the above approach.

## C++

 `// CPP code to find most frequent word in``// an array of strings``#include ``using` `namespace` `std;` `/*structing the trie*/``struct` `Trie {``    ``string key;``    ``int` `cnt;``    ``unordered_map<``char``, Trie*> map;``};` `/* Function to return a new Trie node */``Trie* getNewTrieNode()``{``    ``Trie* node = ``new` `Trie;``    ``node->cnt = 0;``    ``return` `node;``}` `/* function to insert a string */``void` `insert(Trie*& root, string& str, ``int``& maxCount,``            ``string& mostFrequentString)``{``    ``// start from root node``    ``Trie* temp = root;` `    ``for` `(``int` `i = 0; i < str.length(); i++) {` `        ``char` `x = str[i];` `        ``/*a new node if path doesn't exists*/``        ``if` `(temp->map.find(x) == temp->map.end())``            ``temp->map[x] = getNewTrieNode();` `        ``// go to next node``        ``temp = temp->map[x];``    ``}` `    ``// store key and its count in leaf nodes``    ``temp->key = str;``    ``temp->cnt += 1;``    ``if` `(maxCount < temp->cnt) {``        ``maxCount = temp->cnt;``        ``mostFrequentString = str;``    ``}``}` `void` `mostFrequentWord(string arr[], ``int` `n)``{``    ``// Insert all words in a Trie``    ``Trie* root = getNewTrieNode();``    ``int` `cnt = 0;``    ``string key = ``""``;``    ``for` `(``int` `i = 0; i < n; i++)``        ``insert(root, arr[i], cnt, key);` `    ``cout << ``"The word that occurs most is : "` `<< key``         ``<< endl;``    ``cout << ``"No of times: "` `<< cnt << endl;``}` `// Driver code``int` `main()``{``    ``// given set of keys``    ``string arr[]``        ``= { ``"geeks"``,   ``"for"``,   ``"geeks"``, ``"a"``,    ``"portal"``,``            ``"to"``,      ``"learn"``, ``"can"``,   ``"be"``,   ``"computer"``,``            ``"science"``, ``"zoom"``,  ``"yup"``,   ``"fire"``, ``"in"``,``            ``"be"``,      ``"data"``,  ``"geeks"` `};``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``mostFrequentWord(arr, n);` `    ``return` `0;``}`

## Java

 `import` `java.util.HashMap;``import` `java.util.Map;` `public` `class` `TrieTest {` `    ``class` `TrieNode {``        ``Map children;``        ``boolean` `endOfWord;``        ``int` `count;` `        ``public` `TrieNode()``        ``{``            ``children = ``new` `HashMap<>();``            ``endOfWord = ``false``;``            ``count = ``0``;``        ``}``    ``}` `    ``private` `TrieNode root = ``new` `TrieNode();``    ``private` `int` `maxCount = Integer.MIN_VALUE;``    ``private` `String mostFrequentString;` `    ``public` `void` `insert(String word)``    ``{``        ``TrieNode current = root;``        ``for` `(``int` `i = ``0``; i < word.length(); i++) {``            ``Character ch = word.charAt(i);``            ``if` `(current.children.size() == ``0``                ``|| (!current.children.containsKey(ch))) {``                ``current.children.put(ch, ``new` `TrieNode());``            ``}``            ``TrieNode child = current.children.get(ch);``            ``current = child;``        ``}``        ``current.endOfWord = ``true``;``        ``current.count++;``        ``if` `(maxCount < current.count) {``            ``maxCount = current.count;``            ``mostFrequentString = word;``        ``}``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``String[] words``            ``= { ``"geeks"``,  ``"for"``,      ``"geeks"``,   ``"a"``,``                ``"portal"``, ``"to"``,       ``"learn"``,   ``"can"``,``                ``"be"``,     ``"computer"``, ``"science"``, ``"zoom"``,``                ``"yup"``,    ``"fire"``,     ``"in"``,      ``"be"``,``                ``"data"``,   ``"geeks"` `};``        ``TrieTest test = ``new` `TrieTest();``        ``for` `(String word : words) {``            ``test.insert(word);``        ``}``        ` `          ``System.out.println(test.mostFrequentString);``        ``System.out.println(test.maxCount);``        ` `    ``}``}`

## Python3

 `class` `TrieNode:``    ``def` `__init__(``self``):``        ``self``.children ``=` `{}``        ``self``.endOfWord ``=` `False``        ``self``.count ``=` `0` `class` `TrieTest:``    ``def` `__init__(``self``):``        ``self``.root ``=` `TrieNode()``        ``self``.maxCount ``=` `-``float``(``'inf'``)``        ``self``.mostFrequentString ``=` `""` `    ``def` `insert(``self``, word: ``str``):``        ``current ``=` `self``.root``        ``for` `ch ``in` `word:``            ``if` `ch ``not` `in` `current.children:``                ``current.children[ch] ``=` `TrieNode()``            ``current ``=` `current.children[ch]``        ``current.endOfWord ``=` `True``        ``current.count ``+``=` `1``        ``if` `self``.maxCount < current.count:``            ``self``.maxCount ``=` `current.count``            ``self``.mostFrequentString ``=` `word` `if` `__name__ ``=``=` `"__main__"``:``    ``words ``=` `[``"geeks"``,  ``"for"``,      ``"geeks"``,   ``"a"``,``             ``"portal"``, ``"to"``,       ``"learn"``,   ``"can"``,``             ``"be"``,     ``"computer"``, ``"science"``, ``"zoom"``,``             ``"yup"``,    ``"fire"``,     ``"in"``,      ``"be"``,``             ``"data"``,   ``"geeks"``]``    ``test ``=` `TrieTest()``    ``for` `word ``in` `words:``        ``test.insert(word)``    ``print``(test.mostFrequentString)``    ``print``(test.maxCount)`  `# This code is contributed by akashish__`

## C#

 `using` `System;``using` `System.Collections.Generic;` `public` `class` `TrieTest {` `    ``public` `class` `TrieNode {``        ``public` `Dictionary<``char``, TrieNode> children;``        ``public` `bool` `endOfWord;``        ``public` `int` `count;` `        ``public` `TrieNode()``        ``{``            ``children = ``new` `Dictionary<``char``, TrieNode>();``            ``endOfWord = ``false``;``            ``count = 0;``        ``}``    ``}` `    ``private` `TrieNode root = ``new` `TrieNode();``    ``private` `int` `maxCount = ``int``.MinValue;``    ``private` `String mostFrequentString;` `    ``public` `void` `insert(String word)``    ``{``        ``TrieNode current = root;``        ``for` `(``int` `i = 0; i < word.Length; i++) {``            ``char` `ch = word[i];``            ``if` `(current.children.Count == 0``                ``|| (!current.children.ContainsKey(ch))) {``                ``current.children.Add(ch, ``new` `TrieNode());``            ``}``            ``TrieNode child = current.children[ch];``            ``current = child;``        ``}``        ``current.endOfWord = ``true``;``        ``current.count++;``        ``if` `(maxCount < current.count) {``            ``maxCount = current.count;``            ``mostFrequentString = word;``        ``}``    ``}` `    ``public` `static` `void` `Main(String[] args)``    ``{``        ``String[] words``            ``= { ``"geeks"``,  ``"for"``,      ``"geeks"``,   ``"a"``,``                ``"portal"``, ``"to"``,       ``"learn"``,   ``"can"``,``                ``"be"``,     ``"computer"``, ``"science"``, ``"zoom"``,``                ``"yup"``,    ``"fire"``,     ``"in"``,      ``"be"``,``                ``"data"``,   ``"geeks"` `};``        ``TrieTest test = ``new` `TrieTest();``        ``foreach``(String word ``in` `words) { test.insert(word); }``        ` `          ``Console.WriteLine(test.mostFrequentString);``        ``Console.WriteLine(test.maxCount);``        ` `    ``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 `class TrieTest {``  ``constructor() {``    ``this``.root = ``new` `TrieNode();``    ``this``.maxCount = Number.MIN_SAFE_INTEGER;``    ``this``.mostFrequentString;``  ``}` `  ``insert(word) {``    ``let current = ``this``.root;``    ``for` `(let i = 0; i < word.length; i++) {``      ``let ch = word[i];``      ``if` `(current.children.size == 0 || !current.children.has(ch)) {``        ``current.children.set(ch, ``new` `TrieNode());``      ``}``      ``let child = current.children.get(ch);``      ``current = child;``    ``}``    ``current.endOfWord = ``true``;``    ``current.count++;``    ``if` `(``this``.maxCount < current.count) {``      ``this``.maxCount = current.count;``      ``this``.mostFrequentString = word;``    ``}``  ``}` `  ``static main(args) {``    ``let words = [``      ``"geeks"``,``      ``"for"``,``      ``"geeks"``,``      ``"a"``,``      ``"portal"``,``      ``"to"``,``      ``"learn"``,``      ``"can"``,``      ``"be"``,``      ``"computer"``,``      ``"science"``,``      ``"zoom"``,``      ``"yup"``,``      ``"fire"``,``      ``"in"``,``      ``"be"``,``      ``"data"``,``      ``"geeks"``,``    ``];``    ``let test = ``new` `TrieTest();``    ``for` `(let word of words) {``      ``test.insert(word);``    ``}` `    ``console.log(test.mostFrequentString);``    ``console.log(test.maxCount);``  ``}``}` `class TrieNode {``  ``constructor() {``    ``this``.children = ``new` `Map();``    ``this``.endOfWord = ``false``;``    ``this``.count = 0;``  ``}``}` `TrieTest.main();` `// This code is contributed by akashish__`

Output

```The word that occurs most is : geeks
No of times: 3```

Time complexity: O(W*L), where W is the number of words in the given array and L is the length of the words.
Auxiliary Space: O(W*L)

This article is contributed by Aarti_Rathi and Pranav. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.