Find Target Indices After Sorting Array

Find Target Indices After Sorting Array - Problem

You are given a 0-indexed integer array nums and a target element target.

A target index is an index i such that nums[i] == target.

Return a list of the target indices of nums after sorting nums in non-decreasing order. If there are no target indices, return an empty list. The returned list must be sorted in increasing order.

Input & Output

Example 1 — Basic Case

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

› Output: [1,2]

💡 Note: After sorting: [1,2,2,3,5]. Target 2 appears at indices 1 and 2.

Example 2 — No Target Found

$ Input: nums = [1,2,5,2,3], target = 4

› Output: []

💡 Note: After sorting: [1,2,2,3,5]. Target 4 is not found, so return empty list.

Example 3 — Single Element

$ Input: nums = [1], target = 1

› Output: [0]

💡 Note: Array has one element which matches target, so return [0].

Constraints

1 ≤ nums.length ≤ 100
-100 ≤ nums[i] ≤ 100
-100 ≤ target ≤ 100

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8

The key insight is that we don't need to actually sort the array - we just need to count how many elements are smaller than the target and how many equal the target. The target indices in a sorted array would be consecutive positions starting from the count of smaller elements. Best approach is the count-based method. Time: O(n), Space: O(1)

Common Approaches

✓ Bfs

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

Count-Based Approach

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

Instead of sorting, count how many elements are smaller than target and how many equal target. The target indices in a sorted array would be consecutive positions starting from the count of smaller elements.

Sort and Search

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

First sort the entire array in non-decreasing order, then iterate through it to find all indices where the value equals target. This is straightforward but requires actually modifying the array.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct QueueNode {
    struct TreeNode* treeNode;
    struct QueueNode* next;
};

struct Queue {
    struct QueueNode* front;
    struct QueueNode* rear;
    int size;
};

struct Queue* createQueue() {
    struct Queue* q = malloc(sizeof(struct Queue));
    q->front = q->rear = NULL;
    q->size = 0;
    return q;
}

void enqueue(struct Queue* q, struct TreeNode* node) {
    struct QueueNode* qNode = malloc(sizeof(struct QueueNode));
    qNode->treeNode = node;
    qNode->next = NULL;
    
    if (q->rear == NULL) {
        q->front = q->rear = qNode;
    } else {
        q->rear->next = qNode;
        q->rear = qNode;
    }
    q->size++;
}

struct TreeNode* dequeue(struct Queue* q) {
    if (q->front == NULL) return NULL;
    
    struct QueueNode* temp = q->front;
    struct TreeNode* node = temp->treeNode;
    q->front = q->front->next;
    
    if (q->front == NULL) q->rear = NULL;
    
    free(temp);
    q->size--;
    return node;
}

int solution(struct TreeNode* root) {
    if (!root) return 1;
    
    struct Queue* queue = createQueue();
    enqueue(queue, root);
    
    long long minSum = LLONG_MAX;
    int minLevel = 1;
    int level = 1;
    
    while (queue->size > 0) {
        int levelSize = queue->size;
        long long levelSum = 0;
        
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = dequeue(queue);
            levelSum += node->val;
            
            if (node->left) enqueue(queue, node->left);
            if (node->right) enqueue(queue, node->right);
        }
        
        if (levelSum < minSum) {
            minSum = levelSum;
            minLevel = level;
        }
        
        level++;
    }
    
    free(queue);
    return minLevel;
}

struct TreeNode* createNode(int val) {
    struct TreeNode* node = malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = node->right = NULL;
    return node;
}

char* trim(char* str) {
    while (isspace(*str)) str++;
    char* end = str + strlen(str) - 1;
    while (end > str && isspace(*end)) end--;
    *(end + 1) = '\0';
    return str;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove brackets and parse
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    if (!start || !end) {
        printf("1\n");
        return 0;
    }
    
    *end = '\0';
    start++;
    
    char* tokens[1000];
    int tokenCount = 0;
    
    char* token = strtok(start, ",");
    while (token != NULL && tokenCount < 1000) {
        tokens[tokenCount++] = trim(token);
        token = strtok(NULL, ",");
    }
    
    if (tokenCount == 0) {
        printf("1\n");
        return 0;
    }
    
    // Build tree level by level
    struct TreeNode* nodes[1000];
    for (int i = 0; i < 1000; i++) nodes[i] = NULL;
    
    if (strcmp(tokens[0], "null") != 0) {
        nodes[0] = createNode(atoi(tokens[0]));
    }
    
    for (int i = 0; i < tokenCount; i++) {
        if (nodes[i] != NULL) {
            int leftIdx = 2 * i + 1;
            int rightIdx = 2 * i + 2;
            
            if (leftIdx < tokenCount && strcmp(tokens[leftIdx], "null") != 0) {
                nodes[leftIdx] = createNode(atoi(tokens[leftIdx]));
                nodes[i]->left = nodes[leftIdx];
            }
            
            if (rightIdx < tokenCount && strcmp(tokens[rightIdx], "null") != 0) {
                nodes[rightIdx] = createNode(atoi(tokens[rightIdx]));
                nodes[i]->right = nodes[rightIdx];
            }
        }
    }
    
    printf("%d\n", solution(nodes[0]));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

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