Sorting Algorithms

🌐 Sorting Overview

Sorting mechanics generally divide into heavily nested loops for smaller caches ($O(N^2)$ bounds) and recursive Divide & Conquer structures ($O(N \log N)$ limits).

• $O(N^2)$ Baseline: Bubble, Selection, and Insertion Sorts. Best for tiny datasets or nearly perfectly sorted data.
• $O(N \log N)$ Divide & Conquer: Merge Sort and Quick Sort. The industry standards for generalized scaling.
• $O(N)$ Non-Comparison: Counting Sort and Radix Sort. Requires strict bounded constraints on dataset properties (like integers bounding).
• $O(N \log N)$ Native: Heap Sort. In-place mapping without recursion.

🔬 Algorithms Deep Dive

O(N²) Baseline Sorts

Bubble Sort: Propagates maximum values to the end iteratively via pair swaps. Often optimized to break early if no swaps occur.

public void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        boolean swapped = false;
        for (int j = 1; j < arr.length - i; j++) {
            if (arr[j] < arr[j - 1]) {
                swap(arr, j, j - 1);
                swapped = true;
            }
        }
        if (!swapped) break;
    }
}

Selection Sort: Locates absolute current minimum and injects it upfront. Always performs exact $O(N)$ swaps.

public void selectionSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        int minIdx = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minIdx]) minIdx = j;
        }
        swap(arr, i, minIdx);
    }
}

Insertion Sort: Builds the output string progressively. Highly adaptive and routinely utilized inside complex frameworks (like Timsort) natively for handling $N < 64$ sub-chunks due to strict $O(N)$ speed on nearly sorted vectors.

public void insertionSort(int[] arr) {
    for (int i = 1; i < arr.length; ++i) {
        int key = arr[i], j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

Merge Sort (Divide & Conquer)

Splits cleanly down to base elements and merges components together recursively upward guaranteeing stable sorted arrays natively in $O(N \log N)$ constraints.

void sort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        sort(arr, l, m);
        sort(arr, m + 1, r);
        merge(arr, l, m, r); // External $O(N)$ combination
    }
}

Quick Sort

An in-place paradigm separating the domain physically into domains left recursively smaller than a central Pivot and physically greater.

public void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

Non-Comparison Sorts & Heap

Algorithms mapping domains directly to index spaces or structural constraints.

Counting Sort: Hashes bounding integers optimally, heavily consuming memory dynamically proportional to the highest integer natively.

public void countingSort(int[] arr) {
    int max = Arrays.stream(arr).max().getAsInt();
    int[] count = new int[max + 1];
    for (int num : arr) count[num]++;
    for (int i = 0, j = 0; i <= max; i++) {
        while (count[i]-- > 0) arr[j++] = i;
    }
}

Radix Sort: Cascades Counting Sort digit by digit safely preventing space exhaustion reaching $O(d \cdot (N+K))$ outputs perfectly.

public void radixSort(int[] arr) {
    if (arr.length == 0) return;
    int max = Arrays.stream(arr).max().getAsInt();
    for (int exp = 1; max / exp > 0; exp *= 10) {
        countSortByDigit(arr, exp);
    }
}

Heap Sort: Forces elements into a Max/Min Binary Heap. Reaches strictly $O(N \log N)$ time natively with an optimal $O(1)$ embedded space boundary dynamically but lacks the sequential mapping speeds Merge Sort has.

public void heapSort(int[] arr) {
    int n = arr.length;
    // Build heap natively phase
    for (int i = n / 2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }
    // Extract elements globally
    for (int i = n - 1; i > 0; i--) {
        swap(arr, 0, i);
        heapify(arr, i, 0);
    }
}

🔄 Algorithm Variations

Cyclic Sort

Given parameters constraining elements rigidly inside $1$ to $N$, you assign targets manually by calculating targetIdx = nums[i] - 1 strictly bypassing comparison logic for direct index containment bounded strictly to $O(N)$.

int i = 0;
while (i < nums.length) {
    int correct = nums[i] - 1; // The index it SHOULD belong to
    if (nums[i] > 0 && nums[i] <= nums.length && nums[i] != nums[correct]) {
        swap(nums, i, correct);
    } else {
        i++;
    }
}

Dutch National Flag (3-Way Partitioning)

When domains heavily replicate properties (e.g. 0s, 1s, and 2s purely). Using 3 pivot limits natively organizes elements centrally without mapping auxiliary constraints natively dynamically sorting in a single $O(N)$ pass structurally.

int low = 0, mid = 0, high = nums.length - 1;
while (mid <= high) {
    if (nums[mid] == 0) swap(nums, low++, mid++);
    else if (nums[mid] == 1) mid++;
    else swap(nums, mid, high--);
}

QuickSelect

A Quick Sort recursion tree cut fundamentally in half. Instead of sorting both pivot sides, you analyze if the exact Kth pivot sits bounded dynamically processing strictly in amortized $O(N)$ time finding structural Medians optimally natively!

// Find k-th largest implies index (len - k)
int pivotIdx = partition(nums, left, right);
if (pivotIdx == targetK) return nums[targetK];
else if (pivotIdx < targetK) return quickSelect(nums, pivotIdx + 1, right, targetK);
else return quickSelect(nums, left, pivotIdx - 1, targetK);

⏱️ Complexity Analysis

🗺️ 2D Sorting Constraints

Interviewers reliably ask candidates to organize unstructured 2D domains dynamically mapping arrays (e.g. Time Intervals).

// Given coordinates [[start, end], [start, end]]
// Sort dynamically by Start Time rigorously, then break ties via End Time natively!
Arrays.sort(intervals, (a, b) -> {
    if (a[0] != b[0]) {
        return Integer.compare(a[0], b[0]);
    } else {
        return Integer.compare(a[1], b[1]);
    }
});

💪 Practice Problems

public void merge(int[] nums1, int m, int[] nums2, int n) {
    int p1 = m - 1;
    int p2 = n - 1;
    int p = m + n - 1;
    
    while (p2 >= 0) {
        if (p1 >= 0 && nums1[p1] > nums2[p2]) {
            nums1[p--] = nums1[p1--];
        } else {
            nums1[p--] = nums2[p2--];
        }
    }
}

public void sortColors(int[] nums) {
    int low = 0, mid = 0, high = nums.length - 1;
    while (mid <= high) {
        if (nums[mid] == 0) {
            swap(nums, low++, mid++);
        } else if (nums[mid] == 1) {
            mid++;
        } else {
            swap(nums, mid, high--);
        }
    }
}

public int firstMissingPositive(int[] nums) {
    int i = 0;
    while (i < nums.length) {
        int correct = nums[i] - 1;
        if (nums[i] > 0 && nums[i] <= nums.length && nums[i] != nums[correct]) {
            swap(nums, i, correct);
        } else {
            i++;
        }
    }
    for (i = 0; i < nums.length; i++) {
        if (nums[i] != i + 1) return i + 1;
    }
    return nums.length + 1;
}

public int findKthLargest(int[] nums, int k) {
    PriorityQueue<Integer> minHeap = new PriorityQueue<>();
    for (int num : nums) {
        minHeap.offer(num);
        if (minHeap.size() > k) {
            minHeap.poll();
        }
    }
    return minHeap.peek();
}

public int maximumGap(int[] nums) {
    if (nums.length < 2) return 0;
    int min = Arrays.stream(nums).min().getAsInt();
    int max = Arrays.stream(nums).max().getAsInt();
    int gap = Math.max(1, (max - min) / (nums.length - 1));
    
    // The pigeonhole principle guarantees the maximum gap 
    // crosses bucket boundaries instead of being internal to a bucket.
    return computeMaxGap(nums, gap, min, max); // abstracted
}

public int[] topKFrequent(int[] nums, int k) {
    Map<Integer, Integer> count = new HashMap<>();
    for (int num : nums) count.put(num, count.getOrDefault(num, 0) + 1);
    
    List<Integer>[] bucket = new List[nums.length + 1];
    for (int key : count.keySet()) {
        int freq = count.get(key);
        if (bucket[freq] == null) bucket[freq] = new ArrayList<>();
        bucket[freq].add(key);
    }
    
    int[] res = new int[k];
    int index = 0;
    for (int i = bucket.length - 1; i >= 0 && index < k; i--) {
        if (bucket[i] != null) {
            for (int val : bucket[i]) {
                res[index++] = val;
                if (index == k) break;
            }
        }
    }
    return res;
}

public void wiggleSort(int[] nums) {
    for (int i = 0; i < nums.length - 1; i++) {
        if (i % 2 == 0) {
            // Even indices must be <= next
            if (nums[i] > nums[i + 1]) swap(nums, i, i + 1);
        } else {
            // Odd indices must be >= next
            if (nums[i] < nums[i + 1]) swap(nums, i, i + 1);
        }
    }
}

public int minMeetingRooms(int[][] intervals) {
    Arrays.sort(intervals, (a, b) -> a[0] - b[0]); // sort by start
    PriorityQueue<Integer> heap = new PriorityQueue<>(); // min-heap of end times
    for (int[] m : intervals) {
        // If earliest-finishing room ends before this meeting starts → reuse it
        if (!heap.isEmpty() && heap.peek() <= m[0]) heap.poll();
        heap.offer(m[1]); // assign this meeting to a room (push end time)
    }
    return heap.size(); // each entry = one occupied room
}
// [[0,30],[5,10],[15,20]] sorted→ same order
// m=[0,30]: heap empty → push 30. heap=[30]
// m=[5,10]: peek=30 > 5 → new room → push 10. heap=[10,30]
// m=[15,20]: peek=10 ≤ 15 → reuse → pop,push 20. heap=[20,30]
// return heap.size() = 2 ✓

📝 Topic 9 Assignment

✅ Topic Completion Checklist

Check each item before advancing to Topic 10.