Find the Kth Largest Integer in the Array

Find the Kth Largest Integer in the Array - Problem

Array String Divide and Conquer Sorting Heap (Priority Queue) Quickselect Medium

Imagine you're a financial analyst dealing with very large numbers that exceed typical integer limits. You have an array of strings, where each string represents a massive integer without leading zeros, and you need to find the k-th largest value.

🎯 Your Mission: Given an array of numeric strings nums and an integer k, return the string representing the k-th largest integer.

Important: Duplicate numbers count as separate entries. For example, if nums = ["1", "2", "2"], then:

1st largest = "2" (first occurrence)
2nd largest = "2" (second occurrence)
3rd largest = "1"

Why strings? These numbers can be arbitrarily large - think cryptocurrency wallet balances or scientific calculations that would overflow regular integers!

Input & Output

example_1.py — Basic Case

$ Input: nums = ["3", "6", "7", "10"], k = 4

› Output: "3"

💡 Note: The numbers in descending order are: "10" (1st largest), "7" (2nd largest), "6" (3rd largest), "3" (4th largest). So the 4th largest is "3".

example_2.py — With Duplicates

$ Input: nums = ["2", "21", "12", "1"], k = 3

› Output: "2"

💡 Note: Sorted in descending order: "21" (1st), "12" (2nd), "2" (3rd), "1" (4th). The 3rd largest is "2". Note that "21" > "12" > "2" > "1" when comparing as large integers.

example_3.py — Same Length Strings

$ Input: nums = ["1", "2", "2"], k = 2

› Output: "2"

💡 Note: The first "2" is 1st largest, the second "2" is 2nd largest, and "1" is 3rd largest. Duplicates are counted separately.

Visualization

Tap to expand

Understanding the Visualization

Understand the Challenge

We have large numbers as strings that need proper comparison - longer strings represent larger numbers, and equal-length strings are compared lexicographically

Choose the Strategy

For small k: use min-heap (like maintaining top-k leaderboard). For large k: use sorting or quickselect

Implement Comparison

Create a proper comparator that handles string-to-number comparison correctly

Execute Algorithm

Process elements while maintaining our data structure (heap/sorted array) and extract the k-th largest

Key Takeaway

🎯 Key Insight: Use a min-heap of size k to maintain the k largest elements. The root will always be the k-th largest, giving us O(n log k) time complexity - much better than O(n log n) sorting when k is small!

Time & Space Complexity

Time Complexity

⏱️

O(n log n × m)

Sorting takes O(n log n) comparisons, each comparison takes O(m) time where m is average string length

⚡ Linearithmic

Space Complexity

O(log n)

Space used by the sorting algorithm's recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁴
1 ≤ nums[i].length ≤ 100
1 ≤ k ≤ nums.length
nums[i] consists of only digits
nums[i] will not have any leading zeros

Asked in

a Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses a min-heap of size k to efficiently track the k largest elements. This achieves O(n log k) time complexity, which is better than full sorting when k is small. The key insight is that we only need the k-th largest element, not a completely sorted array, so we can use a selection algorithm or heap-based approach for better performance.

Common Approaches

Approach	Time	Space	Notes
✓ Simple Sorting Approach	O(n log n × m)	O(log n)	Sort the array in descending order and return the k-th element
Brute Force (Count Larger Elements)	O(n² × m)	O(1)	For each element, count how many elements are larger to determine its rank
Min-Heap Approach (Optimal)	O(n log k × m)	O(k × m)	Use a min-heap of size k to efficiently track the k largest elements

Simple Sorting Approach — Algorithm Steps

Create a custom comparator for string numbers
Sort the array in descending order using the comparator
Return the element at index k-1

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with unsorted string numbers

Apply Sorting

Sort using custom comparator (length first, then lexicographic)

Select K-th

Return element at index k-1 from sorted array

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    char* strA = (char*)a;
    char* strB = (char*)b;
    int lenA = strlen(strA), lenB = strlen(strB);
    if (lenA != lenB) {
        return lenB - lenA;
    }
    return strcmp(strB, strA);
}

char* findKthLargest(char nums[][100], int n, int k) {
    qsort(nums, n, sizeof(nums[0]), compare);
    return nums[k-1];
}

int main() {
    char nums[4][100] = {"3", "6", "7", "10"};
    int k = 4;
    printf("%s\n", findKthLargest(nums, 4, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n × m)

Sorting takes O(n log n) comparisons, each comparison takes O(m) time where m is average string length

⚡ Linearithmic

Space Complexity

O(log n)

Space used by the sorting algorithm's recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁴
1 ≤ nums[i].length ≤ 100
1 ≤ k ≤ nums.length
nums[i] consists of only digits
nums[i] will not have any leading zeros

89.3K Views

High Frequency

~18 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Simple Sorting Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler