Bitwise operators in Rust - Time & Space Complexity

Time Complexity: Bitwise operators

O(n)

Understanding Time Complexity

Bitwise operators work directly on the bits of numbers. Understanding their time complexity helps us know how fast these operations run as numbers get bigger.

We want to see how the time to do bitwise operations changes when the size of the number changes.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fn bitwise_and(a: u32, b: u32) -> u32 {
    a & b
}

fn bitwise_or(a: u32, b: u32) -> u32 {
    a | b
}

fn bitwise_xor(a: u32, b: u32) -> u32 {
    a ^ b
}
    

This code performs simple bitwise AND, OR, and XOR operations on two 32-bit unsigned integers.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Bitwise operation on each bit of the input numbers.
• How many times: Once per bit, so 32 times for u32 numbers.

How Execution Grows With Input

Each bitwise operation checks each bit once. If the number size doubles, the bits double, so the work doubles too.

Input Size (bits)	Approx. Operations
8	8
32	32
64	64

Pattern observation: The operations grow linearly with the number of bits in the input.

Final Time Complexity

Time Complexity: O(n)

This means the time to do bitwise operations grows in a straight line with the number of bits in the numbers.

Common Mistake

[X] Wrong: "Bitwise operations always run instantly, no matter the number size."

[OK] Correct: Bitwise operations run once per bit, so bigger numbers with more bits take more time.

Interview Connect

Knowing bitwise operation time helps you understand low-level code speed and is useful when optimizing or working with hardware-level tasks.

Self-Check

"What if we used 128-bit numbers instead of 32-bit? How would the time complexity change?"