Can Run Time Complexity of a comparison-based sorting algorithm be less than N logN?

Sorting algorithms are the means to sort a given set of data in an order according to the requirement of the user. They are primarily used to sort data in an increasing or decreasing manner. There are two types of sorting algorithms:

• Comparison-based sorting algorithms
• Non-comparison-based sorting algorithms

Comparison-based sorting algorithms: The elements of an array are compared to each other to sort the array. This type of algorithm checks if one element is greater than or equal to another element in the array. It does not do manipulation on a single array element.

Examples of comparison-based algorithms: Merge sort (compare the elements and copy them), Quicksort (compare the elements and swap them), and Heap sort (Heapify the elements using comparison).

Theorem: Every comparison-based sorting algorithm has the worst-case running time of  \textbf Ω\textbf (\textbf N\textbf l\textbf o\textbf g\textbf N\textbf ) 

Proof:

Let us assume a comparison-based sorting algorithm, and an array of length N. Consider the input array contains array elements like (1, 2, 3, 4, 5, -8, 10, . . ., N)      in some jumbled order. We can order these N elements in N! different ways. 

• Assumptions:
  • 1^st element has N ways of ordering,  2^nd element has (N - 1) ways of ordering,  3^rd element has (N - 2) ways, and so on.
    So, these elements can be arranged in N! ways.
  • Let us suppose, the number of comparisons this algorithm makes in the worst case to arrange is K, i.e., the maximum number of comparisons on the N sized input array is K. To correctly sort all the N! possible inputs algorithm exhibits distinct executions.
• Proof: By the Pigeonhole principle: If n items are put into m containers, with n > m, then at least one container must contain more than one item.
  • Here, the pigeon is N! different inputs. The holes are 2^K different executions.
  • If 2^k < N!  , this means the algorithm executes identically on 2 distinct inputs, and we can’t have a common execution of the sorting algorithm, which is averse to our assumption of a sorting algorithm.
  • Since the sorting method is correct, 2^K ≥ N! ≥ (N/2)^N/2, Where we have used the fact that first N/2 terms of N*(N – 1)* … 2*1 are at least N/2.
  • Taking log base 2 on both sides, K = (N/2)log₂(N/2) = Ω(NlogN) 
  • Hence, every comparison-based sorting algorithm has the worst-case running time that can never be better than  \textbf Ω\textbf (\textbf N\textbf l\textbf o\textbf g\textbf N\textbf )     .

For more details, please refer: Design and Analysis of Algorithms.