Merge pull request #59 from NEHA-AMIN/feature/majority-element

Solution #169 - Neha Amin - 14/07/2025

Author: JRS296

Arrays & Strings/#169 - Majority Element - Easy/Explanation.md

@@ -0,0 +1,126 @@
+# 169. Majority Element
+
+**Difficulty:** *Easy*  
+**Category:** *Arrays, Hash Table, Divide and Conquer*  
+**Leetcode Link:** [Problem Link](https://leetcode.com/problems/majority-element/)
+
+---
+
+## 📝 Introduction
+
+*Given an array nums of size n, return the majority element — the element that appears more than ⌊n / 2⌋ times.*
+
+*Constraints typically include:<br>
+- It is guaranteed that the majority element always exists in the array.*
+
+---
+
+## 💡 Approach & Key Insights
+
+*The problem centers on identifying an element that occurs more than n/2 times. Three approaches are commonly used:<br>
+- Brute-force with nested loops.<br>
+- Better approach using hash map frequency counting.<br>
+- Optimal approach using Moore’s Voting Algorithm for O(n) time and O(1) space.*
+
+---
+
+## 🛠️ Breakdown of Approaches
+
+### 1️⃣ Brute Force / Naive Approach
+
+- **Explanation:** *For each element, count its frequency using a nested loop. If any element occurs more than ⌊n/2⌋ times, return it.*
+- **Time Complexity:** O(n²) – due to nested iterations.
+- **Space Complexity:** O(1)
+- **Example/Dry Run:**
+
+```plaintext
+Input: [3, 2, 3]
+Step 1: Check 3 → appears 2 times → not > 1.5
+Step 2: Check 2 → appears 1 time → not > 1.5
+Return 3
+```
+
+---
+
+### 2️⃣ Better Approach
+
+- **Explanation:** *Use a hash map to store frequencies of each number. As you update counts, if any value exceeds ⌊n/2⌋, return it.*
+- **Time Complexity:** O(n) – single pass to count.
+- **Space Complexity:** O(n) – for storing frequencies.
+- **Example/Dry Run:**
+
+```plaintext
+Input: [2, 2, 1, 1, 1, 2, 2]
+Count Map:
+{2: 1}
+{2: 2}
+{2: 2, 1: 1}
+...
+{2: 4, 1: 3}
+Check: 4 > floor(7/2) = 3 → return 2
+```
+
+---
+
+### 3️⃣ Optimal Approach
+
+- **Explanation:** *Use Moore’s Voting Algorithm. Keep a count and a candidate. If count is zero, pick a new candidate. If current number equals candidate, increment count. Else decrement. At the end, the candidate is the majority element.*
+- **Time Complexity:** O(n) – single pass.
+- **Space Complexity:** O(1) – constant space.
+- **Example/Dry Run:**
+
+```plaintext
+Input: [2, 2, 1, 1, 1, 2, 2]
+Step-by-step:
+candidate = 2, count = 1
+2 == 2 → count = 2
+1 != 2 → count = 1
+1 != 2 → count = 0 → candidate = 1, count = 1
+1 == 1 → count = 2
+2 != 1 → count = 1
+2 != 1 → count = 0 → candidate = 2, count = 1
+Final candidate = 2 → return 2
+```
+
+---
+
+## 📊 Complexity Analysis
+
+| Approach             | Time Complexity | Space Complexity |
+| -------------------- | --------------- | ---------------- |
+| Brute Force          | O(n²)           | O(1)             |
+| Hash Map Counting    | O(n)            | O(n)             |
+| Moore’s Voting Algo  | O(n)            | O(1)             |
+
+---
+
+## 📉 Optimization Ideas
+
+*The Moore’s Voting Algorithm is already optimal, with a single pass and constant space. If the array does not guarantee a majority element, a second pass is needed to verify the candidate.*
+
+---
+
+## 📌 Example Walkthroughs & Dry Runs
+
+```plaintext
+Example: [3, 3, 4, 2, 4, 4, 2, 4, 4]
+Step-by-step:
+candidate = 3, count = 1
+3 == 3 → count = 2
+4 != 3 → count = 1
+2 != 3 → count = 0 → candidate = 2
+...
+Final candidate = 4 → verify by count = 5
+n = 9 → ⌊9/2⌋ = 4 → 5 > 4 → return 4
+```
+
+---
+
+## 🔗 Additional Resources
+
+- [Moore's Voting Algorithm - GeeksforGeeks](https://www.geeksforgeeks.org/theory-of-computation/boyer-moore-majority-voting-algorithm/)
+
+---
+
+Author: Neha Amin <br>
+Date: 19/07/2025

Arrays & Strings/#169 - Majority Element - Easy/majorityElement.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    int majorityElement(vector<int>& nums) {
+        int n = nums.size();
+        int cnt = 0;
+        int el;
+
+        // Boyer-Moore Voting Algorithm
+        for (int i = 0; i < n; i++) {
+            if (cnt == 0) {
+                cnt = 1;
+                el = nums[i];
+            } else if (nums[i] == el) {
+                cnt++;
+            } else {
+                cnt--;
+            }
+        }
+
+        // Optional: Verify if the candidate is actually the majority
+        int cnt1 = 0;
+        for (int i = 0; i < n; i++) {
+            if (nums[i] == el)
+                cnt1++;
+        }
+        if (cnt1 > n / 2)
+            return el;
+        return -1;
+    }
+};

Arrays & Strings/#169 - Majority Element - Easy/majorityElement.py

@@ -0,0 +1,24 @@
+class Solution:
+    def majorityElement(self, nums: List[int]) -> int:
+        n = len(nums)
+        cnt = 0
+        el = None
+
+        # Boyer-Moore Voting Algorithm
+        for i in range(n):
+            if cnt == 0:
+                cnt = 1
+                el = nums[i]
+            elif nums[i] == el:
+                cnt += 1
+            else:
+                cnt -= 1
+
+        # Optional: Verify if el is actually the majority element.
+        cnt1 = 0
+        for i in range(n):
+            if nums[i] == el:
+                cnt1 += 1
+        if cnt1 > n // 2:
+            return el
+        return -1