First Unique Number

First Unique Number - Problem

Array Hash Table Design Queue Data Stream Medium

You have a queue of integers, and you need to retrieve the first unique integer in the queue.

Implement the FirstUnique class:

FirstUnique(int[] nums) - Initializes the object with the numbers in the queue.
int showFirstUnique() - Returns the value of the first unique integer of the queue, and returns -1 if there is no such integer.
void add(int value) - Inserts value to the queue.

Input & Output

Example 1 — Basic Operations

$ Input: FirstUnique firstUnique = new FirstUnique([2,3,5]); firstUnique.showFirstUnique(); firstUnique.add(5); firstUnique.showFirstUnique();

› Output: 2, 2

💡 Note: Initially first unique is 2. After adding 5 (which already exists), 2 is still the first unique.

Example 2 — Remove First Unique

$ Input: FirstUnique firstUnique = new FirstUnique([7,7,7,7,7,7]); firstUnique.showFirstUnique(); firstUnique.add(7); firstUnique.add(3); firstUnique.showFirstUnique();

› Output: -1, 3

💡 Note: All 7s are duplicates so first call returns -1. After adding 3, it becomes the first unique.

Example 3 — Multiple Unique Elements

$ Input: FirstUnique firstUnique = new FirstUnique([809]); firstUnique.showFirstUnique(); firstUnique.add(809); firstUnique.showFirstUnique();

› Output: 809, -1

💡 Note: Initially 809 is unique. After adding another 809, no unique elements remain.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁸
1 ≤ value ≤ 10⁸
At most 50000 calls will be made to showFirstUnique and add.

Visualization

Tap to expand

Asked in

A Amazon 45 B Bloomberg 32 G Google 28 M Microsoft 25

The key insight is to use a hash map for frequency tracking and a doubly linked list for unique elements. The optimal approach achieves O(1) for all operations by maintaining a linked list of unique elements and removing them immediately when they become duplicates. Time: O(1), Space: O(n)

Common Approaches

✓ Math

⏱️ Time: N/A Space: N/A

Brute Force

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

For each showFirstUnique call, iterate through the entire queue to count frequencies of each element, then find the first element with count 1.

Hash Map + Doubly Linked List

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

Maintain a frequency hash map and a doubly linked list of unique elements. When an element becomes non-unique, remove it immediately from the linked list in O(1) time.

Hash Map + Queue

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

Maintain a frequency hash map and a queue. For each showFirstUnique call, iterate through the queue and return the first element with frequency 1 in the hash map.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_QUEUE_SIZE 10000
#define HASH_SIZE 20000
#define OFFSET 10000

typedef struct {
    int queue[MAX_QUEUE_SIZE];
    int size;
} FirstUnique;

int hash_table[HASH_SIZE];

FirstUnique* createFirstUnique(int* nums, int numsSize) {
    FirstUnique* obj = (FirstUnique*)malloc(sizeof(FirstUnique));
    obj->size = numsSize;
    for (int i = 0; i < numsSize; i++) {
        obj->queue[i] = nums[i];
    }
    return obj;
}

int showFirstUnique(FirstUnique* obj) {
    // Clear hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hash_table[i] = 0;
    }
    
    // Count frequencies
    for (int i = 0; i < obj->size; i++) {
        int idx = obj->queue[i] + OFFSET;
        if (idx >= 0 && idx < HASH_SIZE) {
            hash_table[idx]++;
        }
    }
    
    // Find first unique
    for (int i = 0; i < obj->size; i++) {
        int idx = obj->queue[i] + OFFSET;
        if (idx >= 0 && idx < HASH_SIZE && hash_table[idx] == 1) {
            return obj->queue[i];
        }
    }
    return -1;
}

void add(FirstUnique* obj, int value) {
    if (obj->size < MAX_QUEUE_SIZE) {
        obj->queue[obj->size] = value;
        obj->size++;
    }
}

int* parseArray(char* str, int* size) {
    static int nums[MAX_QUEUE_SIZE];
    *size = 0;
    
    char* p = str;
    while (*p && *p != '[') p++;
    if (!*p) return nums;
    p++;
    
    while (*p && *p != ']') {
        while (*p && (isspace(*p) || *p == ',')) p++;
        if (*p == ']') break;
        
        int num = 0;
        int negative = 0;
        if (*p == '-') {
            negative = 1;
            p++;
        }
        
        while (*p && isdigit(*p)) {
            num = num * 10 + (*p - '0');
            p++;
        }
        
        if (negative) num = -num;
        nums[(*size)++] = num;
    }
    
    return nums;
}

int* solution(int* nums, int numsSize, int* returnSize) {
    static int result[3];
    *returnSize = 3;
    
    FirstUnique* obj = createFirstUnique(nums, numsSize);
    
    result[0] = showFirstUnique(obj);
    add(obj, 2);
    result[1] = showFirstUnique(obj);
    add(obj, 3);
    result[2] = showFirstUnique(obj);
    
    free(obj);
    return result;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int size;
    int* nums = parseArray(input, &size);
    
    int returnSize;
    int* result = solution(nums, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

67.5K Views

High Frequency

~35 min Avg. Time

892 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