Employees Earning More Than Their Managers

Employees Earning More Than Their Managers - Problem

Database Easy

You're working as a data analyst for a company and need to investigate salary discrepancies. Given an Employee database table, your task is to find all employees who earn more than their direct managers.

The Employee table contains information about each employee including their ID, name, salary, and their manager's ID. Your goal is to identify potential salary inconsistencies where subordinates earn more than their supervisors.

Column Name	Type
id	int
name	varchar
salary	int
managerId	int

Note: The id is the primary key. Some employees may not have a manager (managerId is null for top-level executives).

Return: The names of all employees who earn more than their managers, in any order.

Input & Output

Basic Example

$ Input: Employee table: +----+-------+--------+-----------+ | id | name | salary | managerId | +----+-------+--------+-----------+ | 1 | Joe | 70000 | 3 | | 2 | Henry | 80000 | 4 | | 3 | Sam | 60000 | null | | 4 | Max | 90000 | null | +----+-------+--------+-----------+

› Output: +------+ | name | +------+ | Joe | +------+

💡 Note: Joe earns $70,000 while his manager Sam earns $60,000. Henry earns $80,000 but his manager Max earns $90,000, so Henry doesn't qualify.

Multiple Results

$ Input: Employee table: +----+--------+--------+-----------+ | id | name | salary | managerId | +----+--------+--------+-----------+ | 1 | Alice | 85000 | 3 | | 2 | Bob | 75000 | 3 | | 3 | Carol | 70000 | null | | 4 | David | 95000 | 5 | | 5 | Eve | 90000 | null | +----+--------+--------+-----------+

› Output: +-------+ | name | +-------+ | Alice | | Bob | | David | +-------+

💡 Note: Alice ($85k) and Bob ($75k) both earn more than their manager Carol ($70k). David ($95k) earns more than his manager Eve ($90k).

No Results

$ Input: Employee table: +----+-------+--------+-----------+ | id | name | salary | managerId | +----+-------+--------+-----------+ | 1 | John | 50000 | 2 | | 2 | Jane | 80000 | null | | 3 | Mike | 60000 | 2 | +----+-------+--------+-----------+

› Output: Empty result set +------+ | name | +------+ +------+

💡 Note: No employee earns more than their manager. John ($50k) and Mike ($60k) both report to Jane ($80k) and earn less than her.

Visualization

Tap to expand

Understanding the Visualization

Identify Relationships

Map each employee to their direct manager using managerId

Compare Salaries

For each employee-manager pair, check if employee salary > manager salary

Filter Results

Keep only employees who earn more than their managers

Return Names

Output the names of qualifying employees

Key Takeaway

🎯 Key Insight: A self-join treats the same table as two separate entities, allowing us to efficiently match employees with their managers and compare their salaries in one optimized database operation.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Database can optimize the join using indexes, typically resulting in O(n log n) complexity

⚡ Linearithmic

Space Complexity

O(n)

Space for the result set and any temporary join tables

⚡ Linearithmic Space

Constraints

1 ≤ Employee table rows ≤ 10⁴
All employee IDs are unique
salary values are positive integers
managerId can be null for top-level employees
No circular management relationships exist

Asked in

G Google 45 a Amazon 38 f Meta 22 ⊞ Microsoft 31

The optimal solution uses a SQL self-join to match employees with their managers. By joining the Employee table with itself (using aliases 'e' for employees and 'm' for managers), we can directly compare salaries in a single efficient query: SELECT e.name FROM Employee e INNER JOIN Employee m ON e.managerId = m.id WHERE e.salary > m.salary

Common Approaches

Approach	Time	Space	Notes
✓ Self-Join Approach (Optimal)	O(n log n)	O(n)	Join the Employee table with itself to match employees with their managers
Nested Subquery Approach	O(n²)	O(1)	For each employee, use a subquery to find their manager's salary

Self-Join Approach (Optimal) — Algorithm Steps

Perform self-join on Employee table (e for employees, m for managers)
Join condition: e.managerId = m.id
Filter where e.salary > m.salary
Select employee names from the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Aliases

Treat Employee table as both 'e' (employees) and 'm' (managers)

Join Tables

Join where e.managerId = m.id

Filter Results

Keep only rows where e.salary > m.salary

Select Names

Return the names of qualifying employees

Code -

solution.c — C

// Optimal SQL solution using self-join
char* sqlQuery = """
SELECT e.name
FROM Employee e
INNER JOIN Employee m ON e.managerId = m.id
WHERE e.salary > m.salary
""";

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Database can optimize the join using indexes, typically resulting in O(n log n) complexity

⚡ Linearithmic

Space Complexity

O(n)

Space for the result set and any temporary join tables

⚡ Linearithmic Space

Constraints

1 ≤ Employee table rows ≤ 10⁴
All employee IDs are unique
salary values are positive integers
managerId can be null for top-level employees
No circular management relationships exist

78.4K Views

High Frequency

~15 min Avg. Time

2.3K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Self-Join Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler