Open in App
Not now

# Most frequent word in an array of strings

• Difficulty Level : Medium
• Last Updated : 10 Jan, 2023

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[0]);`   `    ``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[0]);`   `    ``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[0]);`   `    ``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.

My Personal Notes arrow_drop_up
Related Articles