Department Highest Salary - Practice Coding Problems

Department Highest Salary - Problem

Database Medium

You're working as a HR Analytics Specialist for a large corporation and need to identify the top earners in each department to help with budget planning and performance reviews.

You have access to two database tables:

Employee Table: Contains employee ID, name, salary, and their department ID
Department Table: Contains department ID and department name

Your task is to write a SQL query that finds all employees who have the highest salary within their respective departments. Note that multiple employees can have the same highest salary in a department, and you need to return all of them.

Example: If the Engineering department has two employees earning $90,000 (the highest in that department), both should be included in the result.

Input & Output

example_1.sql — Basic Example

$ Input: Employee table: +----+-------+--------+--------------+ | id | name | salary | departmentId | +----+-------+--------+--------------+ | 1 | Joe | 85000 | 1 | | 2 | Jim | 90000 | 1 | | 3 | Henry | 80000 | 2 | | 4 | Sam | 60000 | 2 | | 5 | Max | 90000 | 1 | +----+-------+--------+--------------+ Department table: +----+-------+ | id | name | +----+-------+ | 1 | IT | | 2 | Sales | +----+-------+

› Output: +-----------+----------+--------+ | Department| Employee | Salary | +-----------+----------+--------+ | IT | Jim | 90000 | | IT | Max | 90000 | | Sales | Henry | 80000 | +-----------+----------+--------+

💡 Note: In the IT department, both Jim and Max have the highest salary of $90,000, so both are included. In Sales, Henry has the highest salary of $80,000.

example_2.sql — Single Employee Per Department

$ Input: Employee table: +----+-------+--------+--------------+ | id | name | salary | departmentId | +----+-------+--------+--------------+ | 1 | Alice | 75000 | 1 | | 2 | Bob | 80000 | 2 | | 3 | Carol | 70000 | 3 | +----+-------+--------+--------------+ Department table: +----+-------+ | id | name | +----+-------+ | 1 | HR | | 2 | IT | | 3 | Legal | +----+-------+

› Output: +-----------+----------+--------+ | Department| Employee | Salary | +-----------+----------+--------+ | HR | Alice | 75000 | | IT | Bob | 80000 | | Legal | Carol | 70000 | +-----------+----------+--------+

💡 Note: Each department has only one employee, so each employee is automatically the highest paid in their respective department.

example_3.sql — All Employees Tied

$ Input: Employee table: +----+-------+--------+--------------+ | id | name | salary | departmentId | +----+-------+--------+--------------+ | 1 | John | 50000 | 1 | | 2 | Jane | 50000 | 1 | | 3 | Jack | 50000 | 1 | +----+-------+--------+--------------+ Department table: +----+-------+ | id | name | +----+-------+ | 1 | Finance| +----+-------+

💡 Note: All employees in Finance have the same salary of $50,000, so all three are tied for the highest salary and should be included in the result.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Single pass with sorting for window function ranking

⚡ Linearithmic

Space Complexity

O(n)

Space for intermediate ranking results

⚡ Linearithmic Space

Constraints

1 ≤ Employee table rows ≤ 10⁴
1 ≤ Department table rows ≤ 10²
Employee.departmentId is a foreign key referencing Department.id
All salary values are positive integers
Department names are unique and not NULL

Asked in

The optimal solution uses window functions with RANK() OVER (PARTITION BY departmentId ORDER BY salary DESC) to efficiently rank employees within their departments. This approach handles ties naturally, requires only a single table scan, and is the most readable and maintainable solution for finding top performers in each group.

Common Approaches

Approach	Time	Space	Notes
✓ Window Function (Optimal)	O(n log n)	O(n)	Use RANK() window function to rank employees by salary within each department
Two-Pass with Subquery	O(n)	O(d)	First find max salary per department, then join to get employees with those salaries
Brute Force (Correlated Subquery)	O(n²)	O(1)	For each employee, check if their salary equals the maximum salary in their department

Window Function (Optimal) — Algorithm Steps

Use RANK() window function to rank employees by salary within each department
Partition by departmentId to group employees by department
Order by salary DESC to get highest salaries first
Select employees where rank = 1 (highest salary in department)
Join with Department table to get department names

Visualization

Tap to expand

Single table scan - Most efficient O(n log n)✅ Handles ties naturally - RANK() assigns same rank to equal values✅ Clean SQL syntax - Modern window function approach🚀 Best practice for finding top N in each group

Step-by-Step Walkthrough

Partition by Department

Group employees by department using PARTITION BY

Rank by Salary

Rank employees within each department by salary DESC

Assign Ranks

RANK() assigns rank 1 to highest salary, handles ties

Filter Rank 1

Select only employees with rank = 1

Join Department

Join with Department table to get department names

Code -

solution.c — C

// C implementation using window function concept
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Comparison function for qsort
int compareEmployeesBySalary(const void* a, const void* b) {
    Employee* empA = *(Employee**)a;
    Employee* empB = *(Employee**)b;
    return empB->salary - empA->salary; // Descending order
}

int findHighestSalariesOptimal(Employee* employees, int empCount, 
                             Department* departments, int deptCount, Result* result) {
    // Create array of pointers to employees for each department
    Employee** deptEmployees[MAX_DEPTS];
    int deptCounts[MAX_DEPTS] = {0};
    
    // Allocate memory for employee pointers
    for (int i = 0; i < MAX_DEPTS; i++) {
        deptEmployees[i] = (Employee**)malloc(empCount * sizeof(Employee*));
    }
    
    // Group employees by department
    for (int i = 0; i < empCount; i++) {
        int deptId = employees[i].departmentId;
        deptEmployees[deptId][deptCounts[deptId]++] = &employees[i];
    }
    
    int resultCount = 0;
    
    // Process each department
    for (int deptId = 0; deptId < MAX_DEPTS; deptId++) {
        if (deptCounts[deptId] > 0) {
            // Sort employees in this department by salary descending
            qsort(deptEmployees[deptId], deptCounts[deptId], sizeof(Employee*), compareEmployeesBySalary);
            
            // Find department name
            char* deptName = NULL;
            for (int j = 0; j < deptCount; j++) {
                if (departments[j].id == deptId) {
                    deptName = departments[j].name;
                    break;
                }
            }
            
            if (deptName != NULL) {
                // Get all employees with maximum salary
                int maxSalary = deptEmployees[deptId][0]->salary;
                for (int k = 0; k < deptCounts[deptId]; k++) {
                    if (deptEmployees[deptId][k]->salary == maxSalary) {
                        strcpy(result[resultCount].department, deptName);
                        strcpy(result[resultCount].employee, deptEmployees[deptId][k]->name);
                        result[resultCount].salary = deptEmployees[deptId][k]->salary;
                        resultCount++;
                    } else {
                        break; // Sorted, so we can break
                    }
                }
            }
        }
    }
    
    // Free allocated memory
    for (int i = 0; i < MAX_DEPTS; i++) {
        free(deptEmployees[i]);
    }
    
    return resultCount;
}

/*
Optimal SQL Query:
SELECT Department, Employee, Salary
FROM (
    SELECT 
        d.name AS Department,
        e.name AS Employee,
        e.salary AS Salary,
        RANK() OVER (PARTITION BY e.departmentId ORDER BY e.salary DESC) as rnk
    FROM Employee e
    JOIN Department d ON e.departmentId = d.id
) ranked
WHERE rnk = 1;
*/

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Single pass with sorting for window function ranking

⚡ Linearithmic

Space Complexity

O(n)

Space for intermediate ranking results

⚡ Linearithmic Space

Constraints

1 ≤ Employee table rows ≤ 10⁴
1 ≤ Department table rows ≤ 10²
Employee.departmentId is a foreign key referencing Department.id
All salary values are positive integers
Department names are unique and not NULL

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Window Function (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler