Sort an Array

Sort an Array - Problem

Array Divide and Conquer Sorting Heap (Priority Queue) Merge Sort Bucket Sort Radix Sort Counting Sort Medium

Given an array of integers nums, sort the array in ascending order and return it.

You must solve the problem without using any built-in functions in O(n log n) time complexity and with the smallest space complexity possible.

Input & Output

Example 1 — Basic Sorting

$ Input: nums = [5,2,8,6,1,9,4]

› Output: [1,2,4,5,6,8,9]

💡 Note: Sort the array in ascending order: all elements arranged from smallest to largest

Example 2 — Already Sorted

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

› Output: [1,2,3,4,5]

💡 Note: Array is already sorted, return as is

Example 3 — Reverse Order

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

› Output: [1,2,3,4,5]

💡 Note: Array in reverse order, needs complete reordering to ascending

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
-5 × 10⁴ ≤ nums[i] ≤ 5 × 10⁴

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8 f Facebook 6

The key insight is to use divide-and-conquer algorithms like merge sort or heap sort to achieve O(n log n) time complexity. Merge sort is optimal for stability and predictable performance, while heap sort achieves optimal O(1) space complexity. Time: O(n log n), Space: O(1) with heap sort or O(n) with merge sort.

Common Approaches

✓ Bubble Sort (Brute Force)

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

Compare each adjacent pair of elements and swap them if they're in the wrong order. Repeat this process until no more swaps are needed. The largest elements 'bubble up' to their correct positions.

Heap Sort

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

First build a max heap from the array, then repeatedly extract the maximum element and place it at the end of the array. This gives us sorted order with O(n log n) time and O(1) space complexity.

Merge Sort

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

Recursively divide the array into two halves until each subarray has one element. Then merge the sorted subarrays back together in the correct order. This divide-and-conquer approach guarantees O(n log n) time complexity.

Bubble Sort (Brute Force) — Algorithm Steps

Step 1: Compare adjacent elements
Step 2: Swap if left > right
Step 3: Repeat until no swaps needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Adjacent

Compare each pair of adjacent elements

Swap if Needed

Swap if left element is greater than right

Repeat

Continue until no swaps are needed

Code -

solution.c — C

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

void merge(int* nums, int left, int mid, int right) {
    int* temp = (int*)malloc((right - left + 1) * sizeof(int));
    int i = left, j = mid + 1, k = 0;
    
    while (i <= mid && j <= right) {
        if (nums[i] <= nums[j]) {
            temp[k++] = nums[i++];
        } else {
            temp[k++] = nums[j++];
        }
    }
    
    while (i <= mid) temp[k++] = nums[i++];
    while (j <= right) temp[k++] = nums[j++];
    
    for (i = left; i <= right; i++) {
        nums[i] = temp[i - left];
    }
    free(temp);
}

void mergeSort(int* nums, int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        mergeSort(nums, left, mid);
        mergeSort(nums, mid + 1, right);
        merge(nums, left, mid, right);
    }
}

void solution(int* nums, int numsSize) {
    if (numsSize > 1) {
        mergeSort(nums, 0, numsSize - 1);
    }
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops - outer loop runs n times, inner loop runs up to n times

⚡ Linearithmic

Space Complexity

O(1)

Only uses a few variables for swapping, no extra arrays

✓ Linear Space

85.0K Views

High Frequency

~15 min Avg. Time

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

Bubble Sort (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler