Intersection of Three Sorted Arrays

Intersection of Three Sorted Arrays - Problem

Given three integer arrays arr1, arr2 and arr3 sorted in strictly increasing order, return a sorted array of only the integers that appeared in all three arrays.

Since all arrays are already sorted, we can take advantage of this property to find common elements efficiently.

Key points:

All arrays are sorted in strictly increasing order (no duplicates within each array)
We need elements that appear in all three arrays
The result should be sorted (naturally will be due to input being sorted)

Input & Output

Example 1 — Basic Case

$ Input: arr1 = [1,2,3,4,5], arr2 = [1,2,5,7,9], arr3 = [1,3,4,5,8]

› Output: [1,5]

💡 Note: Elements 1 and 5 appear in all three arrays. Element 1 is at index 0 in all arrays, and element 5 appears in positions: arr1[4], arr2[2], arr3[3].

Example 2 — No Common Elements

$ Input: arr1 = [197,418,523,876,1356], arr2 = [501,880,1593,1710,1870], arr3 = [521,682,1337,1395,1764]

› Output: []

💡 Note: No element appears in all three arrays, so the result is empty.

Example 3 — Single Common Element

$ Input: arr1 = [1,2,3], arr2 = [2,3,4], arr3 = [2,4,5]

› Output: [2]

💡 Note: Only element 2 appears in all three arrays: arr1[1], arr2[0], arr3[0].

Constraints

1 ≤ arr1.length, arr2.length, arr3.length ≤ 1000
-10⁵ ≤ arr1[i], arr2[i], arr3[i] ≤ 10⁵
All arrays are sorted in strictly increasing order

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 F Facebook 22 M Microsoft 18

The key insight is to leverage the sorted property of all three arrays. The optimal three pointers approach traverses all arrays simultaneously, comparing current elements and advancing pointers strategically. Time: O(n), Space: O(1).

Common Approaches

✓ Bfs

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

Hash Map

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

Brute Force - Triple Nested Loop

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

For every element in the first array, search through the second and third arrays to see if the element exists in both. This is straightforward but inefficient since we don't utilize the sorted property.

Hash Map Frequency Count

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

Iterate through all three arrays and count how many times each element appears. Elements that appear exactly 3 times are present in all three arrays. This approach is more efficient than brute force.

Three Pointers (Optimal)

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

Since all arrays are sorted, we can use three pointers starting at the beginning of each array. We compare the elements at current positions and advance pointers strategically to find common elements in a single pass.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct Node {
    int val;
    struct Node* next;
} Node;

typedef struct {
    Node* head;
    Node* tail;
} List;

typedef struct {
    int* data;
    int front, rear, size;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (int*)malloc(capacity * sizeof(int));
    q->front = q->rear = 0;
    q->size = 0;
    return q;
}

void enqueue(Queue* q, int val) {
    q->data[q->rear] = val;
    q->rear = (q->rear + 1) % 1000;
    q->size++;
}

int dequeue(Queue* q) {
    int val = q->data[q->front];
    q->front = (q->front + 1) % 1000;
    q->size--;
    return val;
}

void addChild(List* children, int parent, int child) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->val = child;
    newNode->next = NULL;
    
    if (children[parent].head == NULL) {
        children[parent].head = newNode;
        children[parent].tail = newNode;
    } else {
        children[parent].tail->next = newNode;
        children[parent].tail = newNode;
    }
}

int* solution(int* pid, int pidSize, int* ppid, int ppidSize, int kill, int* returnSize) {
    List* children = (List*)calloc(50001, sizeof(List));
    
    for (int i = 0; i < pidSize; i++) {
        addChild(children, ppid[i], pid[i]);
    }
    
    int* result = (int*)malloc(pidSize * sizeof(int));
    int count = 0;
    
    Queue* queue = createQueue(1000);
    enqueue(queue, kill);
    
    while (queue->size > 0) {
        int current = dequeue(queue);
        result[count++] = current;
        
        Node* childNode = children[current].head;
        while (childNode) {
            enqueue(queue, childNode->val);
            childNode = childNode->next;
        }
    }
    
    *returnSize = count;
    
    // Free memory
    for (int i = 0; i <= 50000; i++) {
        Node* current = children[i].head;
        while (current) {
            Node* next = current->next;
            free(current);
            current = next;
        }
    }
    free(children);
    free(queue->data);
    free(queue);
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int pid[1000], ppid[1000];
    int pidSize = 0, ppidSize = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token) {
        pid[pidSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    token = strtok(line + 1, ",]");
    while (token) {
        ppid[ppidSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int kill;
    scanf("%d", &kill);
    
    int returnSize;
    int* result = solution(pid, pidSize, ppid, ppidSize, kill, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.4K Views

Medium Frequency

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