Third Maximum Number

Third Maximum Number - Problem

Array Sorting Easy

Given an integer array nums, return the third distinct maximum number in this array.

If the third maximum does not exist, return the maximum number.

Note: You must find the third distinct maximum, meaning duplicates are ignored when counting maximums.

Input & Output

Example 1 — Basic Case with Third Maximum

$ Input: nums = [3,2,1]

› Output: 1

💡 Note: Three distinct numbers exist: 3 (first max), 2 (second max), 1 (third max). Return 1.

Example 2 — Less than 3 Distinct Numbers

$ Input: nums = [1,2]

› Output: 2

💡 Note: Only 2 distinct numbers exist. Third maximum doesn't exist, so return the maximum: 2.

Example 3 — Array with Duplicates

$ Input: nums = [2,2,3,1]

› Output: 1

💡 Note: Distinct numbers: 3 (first max), 2 (second max), 1 (third max). Duplicates are ignored. Return 1.

Constraints

1 ≤ nums.length ≤ 10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

a Amazon 15 🍎 Apple 8 M Microsoft 6 G Google 4

The key insight is to track only the top 3 distinct maximum values. The optimal single-pass approach maintains three variables (first, second, third) and updates them as we scan through the array. Time: O(n), Space: O(1).

Common Approaches

✓ Min Heap of Size 3

⏱️ Time: O(n log 3) Space: O(n)

Maintain a min heap that stores at most 3 distinct elements. The root of the heap will be the third maximum when the heap is full.

Single Pass Tracking

⏱️ Time: O(n) Space: O(1)

Maintain three variables (first, second, third) to track the top 3 distinct maximum values while iterating through the array once.

Sort and Find Third

⏱️ Time: O(n log n) Space: O(n)

Remove duplicates from the array, sort in descending order, then return the third element if it exists, otherwise return the maximum.

Min Heap of Size 3 — Algorithm Steps

Step 1: Use a set to track distinct values seen
Step 2: Maintain a min heap of size at most 3
Step 3: Return heap root if size is 3, else return maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Heap

Add distinct elements to min heap of size 3

Maintain Size

Remove minimum when heap exceeds size 3

Get Result

Heap root is third maximum when size is 3

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void heapify(int arr[], int n, int i) {
    int smallest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    
    if (left < n && arr[left] < arr[smallest])
        smallest = left;
    if (right < n && arr[right] < arr[smallest])
        smallest = right;
    
    if (smallest != i) {
        int temp = arr[i];
        arr[i] = arr[smallest];
        arr[smallest] = temp;
        heapify(arr, n, smallest);
    }
}

int contains(int arr[], int size, int val) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == val) return 1;
    }
    return 0;
}

int solution(int* nums, int numsSize) {
    int heap[3];
    int heapSize = 0;
    int processed[10000];
    int processedSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (!contains(processed, processedSize, nums[i])) {
            processed[processedSize++] = nums[i];
            
            if (heapSize < 3) {
                heap[heapSize++] = nums[i];
            } else if (nums[i] > heap[0]) {
                heap[0] = nums[i];
            }
            
            // Maintain min heap property
            for (int j = heapSize / 2 - 1; j >= 0; j--) {
                heapify(heap, heapSize, j);
            }
        }
    }
    
    if (heapSize == 3) {
        return heap[0];
    } else {
        int max = heap[0];
        for (int i = 1; i < heapSize; i++) {
            if (heap[i] > max) max = heap[i];
        }
        return max;
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int size = 0;
    char *token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log 3)

Each heap operation is O(log 3) = O(1), done n times

⚡ Linearithmic

Space Complexity

O(n)

Set stores distinct elements, heap stores at most 3

⚡ Linearithmic Space

180.0K Views

Medium Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Min Heap of Size 3 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler