How do you solve Debounce on LeetCode?

Debounce (LeetCode #2627) can be solved using Brute Force or Optimal Solution. The optimal approach is Optimal Solution with O(n) time complexity and O(1) space complexity. Key insight: Debouncing is crucial for optimizing performance in event handling.

What is the brute force solution for Debounce?

The brute force approach for Debounce is Brute Force, with O(n²) time complexity and O(1) space complexity. The brute force approach involves executing the function immediately whenever it's called, but we need to track the time of each call and cancel previous calls if they occur within the debounce time. This is straightforward but inefficient. The optimal Optimal Solution approach improves this to O(n).

What are the interview tips for Debounce?

Explain your thought process clearly while coding. Discuss edge cases, such as rapid successive calls. Practice writing code without relying on libraries.

What are common mistakes when solving Debounce?

Not clearing the previous timeout correctly. Failing to pass arguments to the debounced function.

#2627

Debounce

Medium

ClosureTimer Management

LeetCode ↗

Approaches

Brute ForceOptimal

Complexity Comparison

	Brute Force	Optimal Solution★
Time	O(n²)	O(n)
Space	O(1)	O(1)

💡

Intuition

Time O(n)Space O(1)

The optimal approach uses a single timeout reference to manage the calls efficiently. By leveraging closures, we can ensure that the function is only executed once after the debounce period, regardless of how many times it was called.

⚙️

Algorithm

3 steps

1Step 1: Initialize a variable to hold the timeout reference.
2Step 2: When the debounced function is called, clear any existing timeout.
3Step 3: Set a new timeout to invoke the original function after the specified delay, passing any arguments.

solution.py11 lines

1import threading
2
3def debounce(fn, t):
4    timeout_ref = None
5    def debounced(*args):
6        nonlocal timeout_ref
7        if timeout_ref is not None:
8            timeout_ref.cancel()
9        timeout_ref = threading.Timer(t / 1000, lambda: fn(*args))
10        timeout_ref.start()
11    return debounced

ℹ

Complexity note: The time complexity is O(n) because we only maintain a single timeout reference, and each function call only requires constant time operations.

1Debouncing is crucial for optimizing performance in event handling.
2Understanding closures and timers is key to implementing debounce effectively.

Solutions and explanations are original Tejav content. Problem titles © LeetCode — use the LeetCode button above for the full problem statement.