Employees Earning More Than Their Managers

Employees Earning More Than Their Managers - Problem

Database Easy

Given an Employee table, write a SQL query to find all employees who earn more than their direct managers.

The Employee table contains employee information including their ID, name, salary, and manager ID. Each employee has a unique ID, and the managerId column references the ID of their direct manager.

Task: Return the names of employees whose salary is greater than their manager's salary.

Table Schema

Employee

Column Name	Type	Description
`id` PK	int	Primary key, unique employee ID
`name`	varchar	Employee's full name
`salary`	int	Employee's salary amount
`managerId`	int	Foreign key referencing the manager's employee ID

Primary Key: id

Note: Each row represents one employee. The managerId can be NULL for top-level executives who have no manager.

Input & Output

Example 1 — Basic Employee-Manager Comparison

Input Table:

id	name	salary	managerId
1	Joe	70000	3
2	Henry	80000	4
3	Sam	60000
4	Max	90000

Output:

name
Joe

💡 Note:

Joe earns $70,000 and his manager Sam earns $60,000, so Joe earns more than his manager. Henry earns $80,000 but his manager Max earns $90,000, so Henry does not earn more than his manager. Sam and Max have no managers (managerId is NULL), so they are not included in the comparison.

Example 2 — Multiple High Earners

Input Table:

id	name	salary	managerId
1	Alice	85000	3
2	Bob	75000	3
3	Charlie	70000
4	Diana	95000	5
5	Eve	80000

Output:

name
Alice
Bob
Diana

💡 Note:

Alice ($85K) and Bob ($75K) both earn more than their manager Charlie ($70K). Diana ($95K) earns more than her manager Eve ($80K). Charlie and Eve have no managers, so they're not compared against anyone.

Example 3 — No High Earners

Input Table:

id	name	salary	managerId
1	John	50000	2
2	Manager	80000

Output:

name

💡 Note:

John earns $50,000 while his manager earns $80,000. Since John does not earn more than his manager, no employees are returned in the result.

Constraints

1 ≤ Employee.id ≤ 500
0 ≤ Employee.salary ≤ 100000
managerId is a foreign key to id or NULL
All employee names are unique

Visualization

Tap to expand

Understanding the Visualization

Input Table

Employee table with salary and manager relationships

Self Join

Join table with itself on managerId = id

Filter & Select

Where employee salary > manager salary

Key Takeaway

🎯 Key Insight: Self-joins are perfect for comparing records within the same table using foreign key relationships

Asked in

A Amazon 12 G Google 8 M Microsoft 15 F Meta 6

Use a self-join to connect each employee with their manager record, then filter where employee.salary > manager.salary to find employees earning more than their managers.

Table Schema

Employee

Column Name	Type	Description
`id` PK	int	Primary key, unique employee ID
`name`	varchar	Employee's full name
`salary`	int	Employee's salary amount
`managerId`	int	Foreign key referencing the manager's employee ID

Primary Key: id

Note: Each row represents one employee. The managerId can be NULL for top-level executives who have no manager.

Common Approaches

Approach	Time	Space	Notes
✓ Self Join	O(n)	O(1)	Join Employee table with itself to compare employee and manager salaries

Self Join — Algorithm Steps

Step 1: Join Employee table with itself using managerId = id relationship
Step 2: Filter results where employee.salary > manager.salary
Step 3: Select employee names from the filtered results

Visualization

Tap to expand

Step-by-Step Walkthrough

Self Join

Join Employee table with itself

Compare

Filter where employee.salary > manager.salary

Select

Return employee names

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through employee records with hash join

✓ Linear Growth

Space Complexity

O(1)

No additional space beyond join processing

✓ Linear Space

187.4K Views

High Frequency

~8 min Avg. Time

2.8K 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

Table Schema

Input & Output

Constraints

Visualization

Related Problems

Table Schema

Common Approaches

Self Join — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler