Codestin Search App

Friend Requests II: Who Has the Most Friends - Problem

Database Medium

🤝 Friend Requests II: Who Has the Most Friends

You're working on a social media platform's analytics team! Given a database table RequestAccepted that tracks all accepted friend requests, you need to find the person with the most friends.

📊 Table Structure:

Column Name	Type	Description
`requester_id`	int	ID of user who sent the request
`accepter_id`	int	ID of user who accepted the request
`accept_date`	date	When the request was accepted

Key Points:

Each row represents a bidirectional friendship (if A sends to B and B accepts, both A and B are friends)
The combination (requester_id, accepter_id) is unique
You need to return both the person ID and their total friend count
There's guaranteed to be exactly one person with the maximum friends

Goal: Write a SQL query to find who has the most friends and how many friends they have.

Input & Output

example_1.sql — Basic Friend Network

$ Input: RequestAccepted table: | requester_id | accepter_id | accept_date | |--------------|-------------|-------------| | 1 | 2 | 2016-06-03 | | 1 | 3 | 2016-06-08 | | 2 | 3 | 2016-06-08 | | 3 | 4 | 2016-06-09 |

› Output: | id | num | |----|-----| | 3 | 3 |

💡 Note: User 3 has the most friends. They are connected to users 1, 2, and 4. User 3 appears in 3 friendship records: as accepter with users 1 and 2, and as requester with user 4.

example_2.sql — Single Friendship

$ Input: RequestAccepted table: | requester_id | accepter_id | accept_date | |--------------|-------------|-------------| | 1 | 2 | 2016-06-03 |

› Output: | id | num | |----|-----| | 1 | 1 | | 2 | 1 |

💡 Note: Both users have exactly 1 friend each. Either could be returned as they're tied, but the problem guarantees only one person has the maximum.

example_3.sql — Linear Chain

$ Input: RequestAccepted table: | requester_id | accepter_id | accept_date | |--------------|-------------|-------------| | 1 | 2 | 2016-06-03 | | 2 | 3 | 2016-06-04 | | 3 | 4 | 2016-06-05 | | 4 | 5 | 2016-06-06 |

› Output: | id | num | |----|-----| | 2 | 2 | | 3 | 2 | | 4 | 2 |

💡 Note: In a linear chain, users 2, 3, and 4 each have 2 friends (their neighbors), while users 1 and 5 have only 1 friend each.

Constraints

1 ≤ number of accepted requests ≤ 500
1 ≤ requester_id, accepter_id ≤ 500
requester_id ≠ accepter_id (no self-friend requests)
All dates are valid
Guaranteed exactly one person has the maximum number of friends

Visualization

Tap to expand

Understanding the Visualization

Collect All Relationships

Each accepted request creates a bidirectional friendship - both requester and accepter gain a friend

Count Per Person

Use UNION ALL to list each person every time they appear in a friendship, then group and count

Find the Winner

Sort by friend count descending and pick the top person

Key Takeaway

🎯 Key Insight: Friendships are bidirectional, so we count each person's appearances in both requester and accepter roles using UNION ALL, then group and count efficiently.

Asked in

f Facebook 45 in LinkedIn 38 📷 Instagram 25 🐦 Twitter 20

The optimal solution uses UNION ALL to combine both requester_id and accepter_id columns into a single column, then applies GROUP BY with COUNT(*) to efficiently count friendships per user. This approach leverages SQL's built-in aggregation capabilities for maximum performance.

Common Approaches

Approach	Time	Space	Notes
✓ Union All + Group By (Optimal SQL)	O(n log n)	O(n)	Combine both roles into one table, then group and count efficiently
Brute Force (Subqueries for Each User)	O(n²)	O(n)	Count friends for each user individually using separate subqueries

Union All + Group By (Optimal SQL) — Algorithm Steps

Use UNION ALL to combine requester_id and accepter_id into a single 'user_id' column
This creates a unified view where each friendship appears twice (once for each person)
GROUP BY the unified user_id column
COUNT(*) to get total friendships per user
ORDER BY count DESC and LIMIT 1 to get the user with most friends

Visualization

Tap to expand

Step-by-Step Walkthrough

UNION ALL

Combine requester_id and accepter_id into single column

GROUP BY

Group all user IDs and count occurrences

ORDER BY DESC

Sort by count descending to find maximum

Code -

solution.c — C

// Simulating the optimal SQL approach in C
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int requester_id;
    int accepter_id;
    char accept_date[20];
} Request;

typedef struct {
    int user_id;
    int friend_count;
} UserCount;

typedef struct {
    int id;
    int count;
} Result;

Result findMostFriendsOptimal(Request* requests, int size) {
    // Simulate UNION ALL: combine all user appearances
    int* allUsers = malloc(2 * size * sizeof(int));
    int userIndex = 0;
    
    for (int i = 0; i < size; i++) {
        allUsers[userIndex++] = requests[i].requester_id;  // Each requester gains a friend
        allUsers[userIndex++] = requests[i].accepter_id;   // Each accepter gains a friend
    }
    
    // Count friendships per user (simulating GROUP BY COUNT)
    UserCount counts[1000] = {0}; // Assuming user IDs < 1000
    int uniqueUsers = 0;
    
    for (int i = 0; i < 2 * size; i++) {
        int user = allUsers[i];
        int found = 0;
        
        // Find if user already exists in counts
        for (int j = 0; j < uniqueUsers; j++) {
            if (counts[j].user_id == user) {
                counts[j].friend_count++;
                found = 1;
                break;
            }
        }
        
        // If new user, add to counts
        if (!found) {
            counts[uniqueUsers].user_id = user;
            counts[uniqueUsers].friend_count = 1;
            uniqueUsers++;
        }
    }
    
    // Find user with maximum friends
    int maxFriends = 0;
    int mostPopularUser = -1;
    
    for (int i = 0; i < uniqueUsers; i++) {
        if (counts[i].friend_count > maxFriends) {
            maxFriends = counts[i].friend_count;
            mostPopularUser = counts[i].user_id;
        }
    }
    
    free(allUsers);
    Result result = {mostPopularUser, maxFriends};
    return result;
}

/* SQL Query this simulates:
SELECT id, COUNT(*) as num FROM (
    SELECT requester_id as id FROM RequestAccepted
    UNION ALL  
    SELECT accepter_id as id FROM RequestAccepted
) t1 GROUP BY id ORDER BY num DESC LIMIT 1
*/

int main() {
    Request requests[] = {
        {1, 2, "2016-06-03"},
        {1, 3, "2016-06-08"},
        {2, 3, "2016-06-08"},
        {3, 4, "2016-06-09"}
    };
    
    Result result = findMostFriendsOptimal(requests, 4);
    printf("ID: %d, Friends: %d\n", result.id, result.count);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

UNION ALL is O(n), GROUP BY with sorting is O(n log n) due to internal sorting for aggregation

⚡ Linearithmic

Space Complexity

O(n)

Temporary space needed for the unified result set before grouping

⚡ Linearithmic Space

42.0K Views

High Frequency

~12 min Avg. Time

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

🤝 Friend Requests II: Who Has the Most Friends

📊 Table Structure:

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Union All + Group By (Optimal SQL) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler