This approach involves using a HashMap (or dictionary in Python) to count the occurrences of each element in the array. This will help in efficiently checking if an element exists and how many times it appears, which is useful for problems requiring frequency analysis.
Time Complexity: O(n), as it iterates over the array once. Space Complexity: O(1) if the element range is known and constant, or O(k) where k is the range of elements.
1def count_elements(arr):
2 frequency = {}
3 for num in arr:
4 if num in frequency:
5 frequency[num] += 1
6 else:
7 frequency[num] = 1
8 for key, value in frequency.items():
9 print(f'Element {key} appears {value} times')
10
11arr = [1, 3, 1, 2, 3, 4, 5, 3]
12count_elements(arr)This Python function uses a dictionary to count occurrences of each number. It iterates over the array, updating counts directly in the dictionary. Python's dict provides average O(1) time complexity for insertion and lookup operations.
Another approach is sorting the array and then identifying repeated elements by comparison with neighboring elements. This leverages the efficiency of modern sorting algorithms to bring repeated elements together, making it trivial to count consecutive duplicates.
Time Complexity: O(n log n) due to the sort operation. Space Complexity: O(1) if in-place sorting is considered.
1def count_sorted_elements(arr):
2 arr.sort()
3 count = 1
4 for i in range(1, len(arr)):
5 if arr[i] == arr[i - 1]:
6 count += 1
7 else:
8 print(f'Element {arr[i - 1]} appears {count} times')
9 count = 1
10 print(f'Element {arr[-1]} appears {count} times')
11
12arr = [1, 3, 1, 2, 3, 4, 5, 3]
13count_sorted_elements(arr)This Python method sorts the array and iterates through it to count appearances of each number. The sorted array ensures that duplicates are counted consecutively.