Sorting

LeetCode 435: Non-overlapping Intervals From Minimum Removals to Maximum Kept

Subtitle / Summary Non-overlapping Intervals is easier when you stop asking which interval to delete first. First ask how many intervals can remain. Reading time: 8-10 min Tags: Hot100, greedy, intervals, sorting SEO keywords: LeetCode 435, Non-overlapping Intervals, greedy, interval greedy Meta description: A pressure-first Python guide to LeetCode 435 that derives minimum removals from maximum kept intervals and an earliest-ending greedy scan. Problem Requirement You are given an array of intervals intervals. ...

LeetCode 452: Minimum Number of Arrows From Shared Intersections to Interval Greedy

Subtitle / Summary A single arrow does not belong to one balloon. It belongs to a group of balloon intervals that share at least one x-position. Reading time: 9-11 min Tags: Hot100, greedy, intervals, sorting SEO keywords: LeetCode 452, Minimum Number of Arrows to Burst Balloons, greedy, interval greedy Meta description: A pressure-first Python guide to LeetCode 452 that derives shared intersections, an intersection-scanning baseline, and the final arrow position greedy. Problem Requirement You are given an array points. ...

LeetCode 2089: Find Target Indices After Sorting Array ACERS Guide

Subtitle / Summary This problem is a useful bridge between sorting and binary search. After sorting the array, all copies of target become one contiguous block, and the answer is simply every index inside that block. Reading time: 10-12 min Tags: sorting, binary search, range location SEO keywords: Find Target Indices After Sorting Array, LeetCode 2089, lower bound, upper bound Meta description: Sort the array, use lower and upper bounds to find the target block, and return every matching index, with tradeoffs, engineering scenarios, and runnable implementations in six languages. Target Readers Learners connecting sorting with lower/upper bound search Engineers who need all positions of one value after offline sorting Interview candidates reviewing how contiguous blocks form in sorted data Background / Motivation The input array is not sorted, so we cannot apply binary search immediately. But once we sort it, every copy of the same value becomes one continuous segment. ...

Sorting Series (Final): Practical Selection - Choose by Scale, Stability, Memory, Distribution

Practical selection guide: decision tables by scale/distribution/stability/memory, engineering scenarios, test checklist, and common pitfalls to apply the series.

Sorting Series (8): TimSort and Introsort - Engineering Patterns Behind Built-in Sorts

Explain Python/Java TimSort and C++ std::sort Introsort: triggers, stability, complexity, trade-offs, with skeletons and selection guidance.

Sorting Series (7): Non-Comparison Sorting - Counting, Bucket, Radix and the Range/Digit Tradeoff

Explain prerequisites, complexity, implementation details, and pitfalls of non-comparison sorts with multilingual examples for counting, bucket, and radix.

Sorting Series (6): Heap Sort - In-place O(n log n) with Worst-Case Guarantees

Explain heap sort principles, complexity, and engineering scenarios; compare with quick/merge; include multilingual implementations and top-k examples.

Sorting Series (5): Quick Sort - Pivot Strategy, Tail Recursion, Engineering Practice

Comprehensive quicksort guide: pivot selection, three-way partitioning, tail recursion optimization, hybrid sorting practices, with multilingual implementations and engineering guidance.

Sorting Series (4): Merge Sort - Stable Divide and Conquer and External Sorting

Systematic explanation of merge sort principles, stability, space trade-offs, and engineering scenarios with Python/C/C++/Go/Rust/JS implementations and external sorting guidance.

Sorting Series (3): Shell Sort - From Insertion to Gap-Based Efficiency

Explain Shell sort principles, gap strategies, and engineering usage with scenarios and Python/C/C++/Go/Rust/JS implementations.