CareerCup

Method 1: Extra space is allowed. So use HashMap with array elements being key and the count (frequency) being value.
Method 2: Extra space is not allowed. So sort the array, then iterate through the array. For each element, keep iterating forward till u get different element. This way, u can count the number of occurrences of each element.

// Time - O(n)
	// Space - O(n)
	static void modeWithSpace(int[] arr) {
		HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
		
		for(int temp: arr) {
			if(hm.containsKey(temp))
				hm.put(temp, hm.get(temp)+1);
			else
				hm.put(temp, 1);
		}
		System.out.println(hm);
	}

// Time - O(nlogn) + O(n) => O(logn)
	// Space - O(1)
	static void modeNoSpace(int[] arr) {
		Arrays.sort(arr);
		
		int temp, count, j;
		for(int i=0; i<arr.length; i++) {
			temp = arr[i];
			count = 0;
			
			j = i;
			while(temp == arr[j]) {
				count++;
				j++;
				if(j == arr.length) break;
			}
			i = j-1;
			
			System.out.print("\n"+ temp +" => "+ count);
		}
	}

you can emloy part of counting sort, just implement the fist two loop in counting sort.
time is O(n), space is O(k)

typo
Method 2: time - O(nlogn) + O(n) => O(nlogn)

Yes. If extra memory is allowed, place all elements with their frequencies O(n). Now, traverse the hashmap and print all keys with their frequenciesO(n), In the same traversal find the max frequency. Total cost is O(n).

If memory is not allowed. use quicksort or heap sort to sort the elements. Average cost is O(nlogn). No traverse through the array to find frequencies as well as max frequency and it's associated number.
O(nLogn)