Majority Element Moore's Voting Algorithm in DSA Rust - Build from Scratch

Majority Element Moore's Voting Algorithm

📖 Scenario: Imagine you have a list of votes where each vote is a number representing a candidate. You want to find the candidate who got more than half of the votes. This is called the majority element.

🎯 Goal: You will write a Rust program that uses Moore's Voting Algorithm to find the majority element in a list of votes.

📋 What You'll Learn

Create a vector called votes with the exact values: [2, 2, 1, 1, 1, 2, 2]

Create a variable called count and set it to 0

Create a variable called candidate and set it to 0

Use a for loop with variable vote to iterate over votes.iter()

Inside the loop, implement Moore's Voting Algorithm logic to update candidate and count

Print the final candidate as the majority element

💡 Why This Matters

🌍 Real World

Finding the majority element is useful in voting systems, polling, and data analysis where you want to identify the most common item quickly.

💼 Career

Understanding Moore's Voting Algorithm helps in roles involving data processing, algorithm design, and software development where efficient majority detection is needed.

1

Create the votes vector

Create a vector called votes with the exact values [2, 2, 1, 1, 1, 2, 2].

DSA Rust

# Create the votes vector with the given values
# Your code here

Hint

Use let votes = vec![2, 2, 1, 1, 1, 2, 2]; to create the vector.

2

Initialize count and candidate variables

Create a variable called count and set it to 0. Create a variable called candidate and set it to 0.

DSA Rust

fn main() {
    let votes = vec![2, 2, 1, 1, 1, 2, 2];
    // Initialize count and candidate
    // Your code here
}

Hint

Use let mut count = 0; and let mut candidate = 0; to create mutable variables.

3

Implement Moore's Voting Algorithm loop

Use a for loop with variable vote to iterate over votes.iter(). Inside the loop, if count is 0, set candidate to *vote. If vote equals candidate, increase count by 1, else decrease count by 1.

DSA Rust

fn main() {
    let votes = vec![2, 2, 1, 1, 1, 2, 2];
    let mut count = 0;
    let mut candidate = 0;

    // Implement Moore's Voting Algorithm loop
    // Your code here
}

Hint

Use a for loop and update candidate and count as per Moore's Voting Algorithm.

4

Print the majority element

Print the final candidate as the majority element using println!("{}", candidate);.

DSA Rust

fn main() {
    let votes = vec![2, 2, 1, 1, 1, 2, 2];
    let mut count = 0;
    let mut candidate = 0;

    for vote in votes.iter() {
        if count == 0 {
            candidate = *vote;
        }
        if *vote == candidate {
            count += 1;
        } else {
            count -= 1;
        }
    }

    // Print the majority element
    // Your code here
}

Hint

Use println!("{}", candidate); to print the majority element.

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