Majority Element Moore's Voting Algorithm in DSA Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the Majority Element in an array?

The Majority Element is the element that appears more than half the size of the array (n/2 times).

intermediate

What is the main idea behind Moore's Voting Algorithm?

It finds the majority element by maintaining a candidate and a count, increasing count for the same element and decreasing for different ones, ensuring the candidate at the end is the majority if it exists.

beginner

In Moore's Voting Algorithm, what happens when the count reaches zero?

When count reaches zero, the algorithm picks the next element as a new candidate and resets the count to one.

intermediate

Why do we need a second pass after finding the candidate in Moore's Voting Algorithm?

Because the first pass only finds a candidate, the second pass confirms if this candidate actually appears more than n/2 times.

beginner

What is the time complexity of Moore's Voting Algorithm?

The time complexity is O(n) because it makes at most two passes over the array.

What does Moore's Voting Algorithm primarily maintain during its execution?

A A sorted array

B A candidate element and a count

C A hash map of element frequencies

D A stack of elements

Moore's Voting Algorithm keeps track of a candidate and a count to find the majority element efficiently.

When does Moore's Voting Algorithm change its candidate element?

A When the array is sorted

B When count is positive

C When count becomes zero

D At the start only

The candidate changes when the count drops to zero, indicating the previous candidate is no longer supported.

What is the minimum number of times the majority element appears in the array?

A More than n/2 times

B Exactly n/2 times

C Less than n/2 times

D At least once

By definition, the majority element appears more than half the size of the array.

Why is a second pass needed after finding the candidate in Moore's Voting Algorithm?

A To verify the candidate's frequency

B To sort the array

C To reset the count

D To find the minimum element

The second pass confirms if the candidate actually appears more than n/2 times.

What is the space complexity of Moore's Voting Algorithm?

A O(n)

B O(n^2)

C O(log n)

D O(1)

Moore's Voting Algorithm uses constant extra space, only storing a candidate and a count.

Explain how Moore's Voting Algorithm finds the majority element in an array.

Think about how the algorithm keeps track of a potential majority element while scanning the array.

Describe why Moore's Voting Algorithm is efficient compared to counting frequencies of all elements.

Consider time and space usage compared to other methods.

Practice

1. What is the main purpose of the Moore's Voting Algorithm in the context of arrays?

easy

A. To sort the array in ascending order

B. To find the element that appears more than half the times in the array

C. To find the smallest element in the array

D. To reverse the array elements

Solution

1. Step 1: Understand the problem Moore's Voting Algorithm solves

   The algorithm is designed to find the majority element, which is the element that appears more than half the times in an array.

2. Step 2: Compare with other options

   Sorting, finding smallest, or reversing are unrelated to majority element detection.

3. Final Answer:

   To find the element that appears more than half the times in the array -> Option B

4. Quick Check:

   Majority element = element with > n/2 occurrences [OK]

Hint: Majority element appears more than half times [OK]

Common Mistakes:

• Confusing majority element with most frequent element
• Thinking it sorts the array
• Assuming it finds smallest or largest element

2. Which of the following Rust code snippets correctly initializes the variables for Moore's Voting Algorithm?

easy

A. let count = None; let candidate = None;

B. let count = 0; let candidate = 0;

C. let mut count = None; let mut candidate = 0;

D. let mut count = 0; let mut candidate = 0;

Solution

1. Step 1: Identify correct variable types and mutability

   Moore's Voting Algorithm requires mutable count and candidate variables. Candidate starts as 0 (sentinel value), count as 0.

2. Step 2: Check each option

   let mut count = 0; let mut candidate = 0; correctly uses mutable variables with candidate as 0 and count as 0. Others either lack mutability or wrong types.

3. Final Answer:

   let mut count = 0; let mut candidate = 0; -> Option D

4. Quick Check:

   Mutable count=0 and candidate=0 initialization [OK]

Hint: Candidate starts 0, count starts 0, both mutable [OK]

Common Mistakes:

• Not using mutable variables
• Initializing candidate with None instead of 0
• Using None for count variable

3. What will be the output of the following Rust code using Moore's Voting Algorithm?

fn majority_element(nums: &[i32]) -> i32 {
    let mut count = 0;
    let mut candidate = 0;
    for &num in nums {
        if count == 0 {
            candidate = num;
        }
        if num == candidate {
            count += 1;
        } else {
            count -= 1;
        }
    }
    candidate
}

fn main() {
    let arr = [2, 2, 1, 1, 1, 2, 2];
    println!("{}", majority_element(&arr));
}

medium

A. 2

B. 1

C. 0

D. Compilation error

Solution

1. Step 1: Trace the algorithm with given array

   Array: [2, 2, 1, 1, 1, 2, 2]. Candidate and count update as follows:
   - Start: count=0, candidate=0
   - num=2, count=0 -> candidate=2, count=1
   - num=2 == candidate -> count=2
   - num=1 != candidate -> count=1
   - num=1 != candidate -> count=0
   - num=1, count=0 -> candidate=1, count=1
   - num=2 != candidate -> count=0
   - num=2, count=0 -> candidate=2, count=1

2. Step 2: Final candidate is 2

   After loop, candidate is 2, which is the majority element.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Majority element found = 2 [OK]

Hint: Track candidate and count changes stepwise [OK]

Common Mistakes:

• Not updating candidate when count is zero
• Miscounting increments and decrements
• Assuming first element is always majority

4. Identify the bug in this Rust implementation of Moore's Voting Algorithm:

fn majority_element(nums: &[i32]) -> i32 {
    let mut count = 0;
    let mut candidate = 0;
    for &num in nums {
        if count == 0 {
            candidate = num;
        }
        if num != candidate {
            count += 1;
        } else {
            count -= 1;
        }
    }
    candidate
}

medium

A. The count increment and decrement conditions are reversed

B. Candidate should be initialized to None

C. Loop should iterate over mutable references

D. Function should return Option<i32> instead of i32

Solution

1. Step 1: Analyze count update logic

   In Moore's Voting Algorithm, count increases when current number equals candidate, and decreases otherwise. Here, conditions are reversed.

2. Step 2: Identify correct logic

   Correct logic: if num == candidate { count += 1 } else { count -= 1 }.

3. Final Answer:

   The count increment and decrement conditions are reversed -> Option A

4. Quick Check:

   Count updates reversed cause wrong majority [OK]

Hint: Count++ if equal candidate, else count-- [OK]

Common Mistakes:

• Swapping increment and decrement conditions
• Not resetting candidate when count is zero
• Ignoring mutability of variables

5. Given an array where no element appears more than half the time, what will Moore's Voting Algorithm return?
Example: [1, 2, 3, 4]
How can you modify the algorithm to correctly handle this case?

hard

A. It returns zero; change candidate initialization to -1

B. It returns None automatically; no modification needed

C. It returns a candidate anyway; add a verification step counting candidate occurrences

D. It panics at runtime; wrap code in Result to handle errors

Solution

1. Step 1: Understand algorithm behavior without majority

   Moore's Voting Algorithm always returns a candidate even if no majority exists, because it only finds a potential majority.

2. Step 2: Modify algorithm to verify candidate

   After finding candidate, count its occurrences in the array. If count > n/2, candidate is majority; else no majority exists.

3. Final Answer:

   It returns a candidate anyway; add a verification step counting candidate occurrences -> Option C

4. Quick Check:

   Verification step needed to confirm majority [OK]

Hint: Verify candidate count after algorithm completes [OK]

Common Mistakes:

• Assuming algorithm returns None if no majority
• Not verifying candidate count after selection
• Expecting runtime errors for no majority