Majority Element Moore's Voting Algorithm in DSA Rust - Time & Space Complexity

Time Complexity: Majority Element Moore's Voting Algorithm

O(n)

Understanding Time Complexity

We want to understand how the time needed to find the majority element grows as the list gets bigger.

How many steps does the algorithm take when the input size changes?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

This code finds the majority element by keeping track of a candidate and adjusting a count as it goes through the list once.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: One loop that goes through each number in the list once.
• How many times: Exactly once for each element in the input list.

How Execution Grows With Input

As the list gets bigger, the algorithm checks each number once, so the steps grow directly with the size.

Input Size (n)	Approx. Operations
10	About 10 checks
100	About 100 checks
1000	About 1000 checks

Pattern observation: The number of steps grows in a straight line with the input size.

Final Time Complexity

Time Complexity: O(n)

This means the time to find the majority element grows directly with the number of elements in the list.

Common Mistake

[X] Wrong: "The algorithm needs to check pairs or do nested loops, so it takes longer than just one pass."

[OK] Correct: The algorithm smartly keeps a candidate and count, so it only needs one simple loop through the list.

Interview Connect

Knowing this algorithm's time complexity shows you can find efficient solutions that scan data once, a skill valued in many coding challenges.

Self-Check

"What if we had to verify the candidate by counting its occurrences after the first pass? How would the time complexity change?"

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