Sorting is one of the most fundamental techniques in competitive programming because it serves as a building block for solving a wide range of problems. Many problems require you to sort data before performing further operations, such as finding the median, detecting duplicates, or solving problems involving intervals or ranges. The most commonly used sorting algorithms in competitive programming are quicksort, mergesort, and heapsort, all of which have an average-case time complexity of O(n log n). These algorithms are fast enough to handle input sizes up to 100,000 or more elements, which is often the upper limit in contests. In addition to these comparison-based sorting algorithms, you might also encounter non-comparison-based algorithms like radix sort or counting sort, which can achieve linear time complexity (O(n)) under certain conditions. Understanding how different sorting algorithms work and when to use them is essential for solving problems efficiently. For example, if the input size is small, an O(n^2) algorithm like insertion sort or selection sort may be acceptable, but for larger inputs, you'll need to rely on more efficient algorithms like quicksort or mergesort. Sorting can also be used as a preprocessing step in problems that involve searching, dynamic programming, or optimization. For instance, in interval scheduling problems, sorting intervals by their end time allows you to apply a greedy algorithm to find the optimal solution. Similarly, in problems involving geometric properties or number theory, sorting the input can help simplify the problem and make it easier to solve.