The Search-o-Sort Theory

Abstract

In the modern era of informatics, where data are very important, efficient management of data is necessary and critical. Two of the most important data management techniques are searching and data ordering (technically sorting). Traditional sorting algorithms work in quadratic time $\left(\mathcal{O}\left(x^2\right)\right)$, and in the optimized cases, they take linearithmic time $\left(\mathcal{O}\left(x·\log x\right)\right)$, with no existing method surpass this lower bound, given arbitrary data, i.e., ordering a list of cardinality x in $\left(\mathcal{O}\left(x·\log x\right)-ϵ\left(x\right)\right)\forall ϵ\left(x\right)>0$. This research proposes Search-o-Sort, which reinterprets sorting in terms of searching, thereby offering a new framework for ordering arbitrary data. The framework is applied to classical search algorithms,–Linear Search, Binary Search (in general, k-ary Search), and extended to more optimized methods such as Interpolation and Jump Search. The analysis suggests theoretical pathways to reduce the computational complexity of sorting algorithms, thus enabling algorithmic development based on the proposed viewpoint.

1. Introduction

In the digital age, exponential growth of data necessitates the need for efficient data management, for which, sorting and searching hold foundational roles in information organization and retrieval. Sorting is fundamental to numerous computational tasks, with widespread applications from database indexing to network routing and machine learning.

1.1. General Context

The objective of Sorting Algorithms is to arrange a collection of elements in a specific order (by their magnitude). If one were to attempt to establish a broad, amorphous explanation, one could begin by saying that it is a procedure that examines the collection of all permutations $\mathcal{P}\left(A\right)$ for a potential permutation in which each of the components that make up the index is monotonically organized. It is guaranteed that there always exists an instance ${\mathcal{P}}_i\in \mathcal{P}\left(A\right)$ such that in ${\mathcal{P}}_i\left(A\right)$, $A_i\ge A_{i+1}$ or $A_i\le A_{i+1}\forall i\in n$, where n is the cardinality of the dataset. The classical sorting lower bound is well-established through decision tree models, where each comparison narrows the set of possible permutations. This results in a minimum of ${\log }_2(n!)$ comparisons, which, by Stirling’s approximation, gives rise to the $\mathsf{\Omega }\left(n\log n\right)$ bound (refer to Appendix A).

Claim. 

For any sorting Algorithm, the minimal time, any Algorithm can hit is $\mathsf{\Omega }\left(n{\log }_{2}n\right)$.

Proof. 

Let us attempt to understand sorting in the context of searching (which is the backbone of this research). Each categorized component ultimately seeks its correct position within the set. Assume it is required to evacuate the element ${\alpha }_i$ to its original location. To return to its original location, one will have to look in as many n places as possible. Now, after it has been dumped at its original location and moved on to the subsequent element of ${\alpha }_i$, to evict it to its true location, one must look for it at most $n-1$ locations, and the number of locations to be sought varies as follows: $n-3$, $n-4$, $n-5$, $n-6$, …, 1. There are numerous searching algorithms available, such as linear search, binary search, and interpolation search [1], but the quickest searching technique created thus far without enforcing any stringent restrictions is binary search [2], which conducts searches in logarithmic time $\left({\mathcal{T}}_{\mathrm{search}}^{\mathrm{optimal}}\left(x\right)={\log }_{2}x,\mathrm{for}\mathrm{a}\mathrm{list}\mathrm{of}\mathrm{cardinality}x\right)$. So, the total time, as per the computational complexities, will be

$$\mathcal{T}\left(n\right)={\log }_{2}n+{\log }_2\left(n-1\right)+{\log }_2\left(n-2\right)+\dots +{\log }_{2}1$$

which can be further delineated as

$$\mathcal{T}\left(n\right)={\log }_2\left(\prod _{i=0}^{n-1}\left(n-i\right)\right)={\log }_2\left(n!\right)$$

Now, there exist some approximations with bounds for the general factorial, Stirling’s Approximation, and Ramanujan’s Approximation for the Gamma Function, to name a few. In some recent works, it was proved using the aforementioned approximation that the minimum computational time taken by a sorting Algorithm to sort a given set of data is of the order of $n\log \left(n\right)$ without tampering with the general architecture of the processor. Drawing from that work and utilizing Srinivasa Ramanujan’s approximation of the Euler Gamma Function, we can conclude

$$\mathcal{T}{\left(n\right)}_{\min }={\log }_{2}n!$$

(1)

Thus, from Equation (1), one gets

$$\mathcal{T}{\left(n\right)}_{\min }\approx n{\log }_2\left(n\right)$$

(2)

since, $\mathsf{\Gamma }\left(1+x\right)\approx \sqrt{\pi }{\left({\displaystyle \frac{x}{e}}\right)}^x\left(\sqrt[6]{8x^3+4x^2+x+{\displaystyle \frac{{\theta }_x}{30}}}\right)$, where, ${\theta }_x\to 1\mathrm{as}x\to \infty ,{\displaystyle \frac{3}{10}}<{\theta }_x<1$

   □

1.2. Motivation

Now, since there exists a tight minimal bound for the sorting algorithms, “what’s the point behind this work?” In the reference drawn above, binary searching Algorithm was enforced to search the individual elements before sorting. Over time, scientists and algorithmists came up with a variety of new algorithms that could search for a given key in a hump of data quite optimally (compared to the primitive algorithms). By using these searches, we could make use of some optimized algorithms, which would have an edge over other prevalent algorithms (in terms of sorting).

1.3. Literature Review

In the literature, there exist limited but foundational works on deterministic searching algorithms. These search algorithms serve as the basis for Search-o-Sort. Manna and Waldinger, in their seminal work, “The origin of a binary-search paradigm” [2], introduced 2-ary Search (commonly known as binary search). In recent times, several variants of the binary search exists [3,4,5], operating in ${\mathcal{O}}^{*}\left(x{\log }_{2}x\right)$ time (amortized). The proposition of “original” binary search was further extended to 3-ary (ternary) Search [6] by Bajwa et al., and was generalized to k-ary Search [7] by Dutta et al. Contrary to these methods, Interpolation Search [1] suggested a newer perspective for search algorithms. The computational complexity of Interpolation Search is unlike k-ary Search algorithms, which was explained by the authors of Interpolation Search in their follow-up work, “Understanding the complexity of Interpolation Search” [8]. Another out-of-the-box searching Algorithm, Jump Search, was proposed by Shneiderman [9]. These algorithms (in general) serve as the basis for analysis of the proposed Search-o-Sort theory.

1.4. Contribution and Scope

This research introduces Search-o-Sort theory, a conceptual framework that identifies sorting as a composition of iterative searching operations. Thus, in the proposed mathematical formulation, the total cost of sorting Algorithm is modeled as a summation of successive search costs. This model is applied and validated across multiple searching paradigms, Binary Search (in general, k-ary Search), Interpolation Search, and Jump Search. By embedding these search algorithms into the sorting process, we derive computational costs and interpret their implications on the sorting bounds. Our analysis suggests that alternative searching techniques can offer promising directions for reducing effective sorting time, particularly when specialized assumptions or approximations are permitted (which is possible nowadays due to recent advancement in computer architecture).

1.5. Document Structure

The rest of the manuscript is organized as follows, Section 2 introduces the Search-o-Sort theory and its foundational proposition. Section 2.3, Section 2.4, Section 2.5 and Section 2.6 explore the applications of Search-o-Sort theory across k-ary Search, Interpolation Search, and Jump Search, respectively. Finally, Section 3 concludes the paper with insights on the implications of Search-o-Sort theory and scope for future research.

2. Search-o-Sort

One can verify Sorting in the context of Searching, as indicated in the introduction. To summarize, every component that is being ordered is subsequently looking for its correct location in the set. Assume it is required to evacuate the element ${\alpha }_i$ to its original location. To get back to its unique location, one will have to look in all of the n places. Now, once it is dropped at its original place, it will move to the next element of ${\alpha }_i$, and to evacuate it to its actual place, one will have to search at most $n-1$ places and in this way, the number of places to be searched varies, coagulated with subsequent decrements. Now, here comes the million-dollar question—which Algorithm should be tested for searching the elemental position invoked with sorting? Works have been published which make use of Binary Search (Equation (2)). Here, firstly, the Search-o-Sort (see Section 2.1) is proposed, and its further expansion for the theoretical provenance is achieved by its application on k-ary (see Section 2.3), Interpolation (see Section 2.4), and Jump Search (see Section 2.6) as intermediate Searching Algorithms for their respective sorting paradigms, as discussed in the Search-o-Sort.

2.1. The Proposition

Suppose we have a set of n elements, ${\alpha }_1,{\alpha }_2,\dots ,{\alpha }_n$, and we are aiming to find a permutation of this set of n numbers, such that the elements in the permutation follow a monotonic order by their magnitude. Suppose the new permutation after sorting is ${\beta }_1,{\beta }_2,\dots ,{\beta }_n$. Now, each of these elements ${\beta }_1,{\beta }_2,\dots ,{\beta }_n$, are selected from the list, ${\alpha }_1,{\alpha }_2,\dots ,{\alpha }_n$ in iterations. The selection cost will depend on the cardinality of the input sequence. Let us suppose, that the cost is $\varphi \left(n\right)$. Now, once one selection is complete from the sequence of n entries, it will be left with $n-1$ more entries to be selected. In the next iteration, the cost would be reduced to $\varphi (n-1)$, and in the consecutive iterations, the cost will finally converge at $\varphi \left(1\right)$. Thus, it would be correct to undertake a summation of each of these costs, $\varphi \left(n\right),\varphi (n-1),\dots ,\varphi \left(1\right)$ (see Figure 1) to determine the cost of finding the required permutation with elements arranged in monotonic order by their magnitude. So, the Computational Time Complexity of the Sorting Algorithm, which incorporates a Searching Algorithm of Computational Expense, $\varphi \left(n\right)$, would be

$${\mathcal{T}}_{\mathrm{sort}}\left(n\right)=\sum _{i=1}^n{\mathcal{T}}_{\mathrm{search}}\left(i\right)=\sum _{i=1}^n\varphi \left(i\right)$$

(3)

Corollary 1.

For any sorting Algorithm, if the intermediate searching Algorithm claims a computational expense of $\varphi \left(n\right)$, the computational complexity of the sorting Algorithm will be $n\times \varphi \left(n\right)$.

Proof. 

The proof follows from the proposition (Equation (3)), of the Search-o-Sort, and since it is known that

$${\displaystyle \frac{1}{\varphi \left(n\right)}}{\int }_{i=1}^{n+1}\varphi \left(i\right)\mathrm{d}i=\mathcal{O}\left(n\right)$$

NOTE: This proof (and following predicates in the manuscript) intentionally adoptions continuous summation (integrals, over discrete summation) for better convergence (as permissible in an asymptotic setting).

$\mathcal{O}(.)$ is the Big-Oh Asymptotic Notation (refer to Appendix A.1), and as per the properties of Asymptotes, if one has a function $f\left(n\right)$, and if,

$$g\left(n\right)=\mathcal{O}\left(f\left(n\right)\right)$$

then,

$$c·f\left(n\right)\ge g\left(n\right);\mathrm{assuming}f\left(n\right)\ge 0,g\left(n\right)\ge 0$$

Thus $\exists c,n_0(n>n_0)$, such that

$${\mathcal{T}}_{\mathrm{sort}}\left(n\right)=n\times {\mathcal{T}}_{\mathrm{search}}\left(n\right)$$

(4)

   □

In the following subsections, proposals of the novel sorting paradigms making use of the Interpolation, Jump, and k-ary Searching Techniques as the intermediate are made, and investigated. The aforementioned corollary (Equation (4)) is also verified.

2.2. The Realization

This Search-o-Sort theory might appear circular at first glance, as it invokes binary search as an intermediate for sorting, but this is not the case. This section aims to bridge the realization of the proposed Search-o-Sort theory. To this end, let us consider an infinitely long incline as depicted in Figure 2, and for each integer, there exist respective holes on the hypotenuse. Now, the list to be sorted consists of a fixed set of integers, which are to be sorted by their magnitude. Consider each of the integers as spheres of the respective radius, and the polarity, for example, the integer +7, would fit inside the hole of a radius of 7 units, and positive polarity, i.e., if the ball passes by the −7 hole, it would be repelled by the positive polarity of the hole, and even if it falls inside holes of smaller radius, it would be thrown off by its inertial force (refer Figure 2b. It will only fit inside a hole if both the polarity and the radius match (refer Figure 2c). We would roll each ball corresponding to each integer from the list to be ordered from the $-\infty$ hole, and let them roll until they find their exact position.

Now since checking each hole will consume ∞ time, we would initially, run the Min-Max Algorithm (refer to Appendix B) in $\mathcal{O}\left(n\right)$ to obtain knowledge about the maximum and minimum of the integral list (i.e., assuming inputs to be linearly distributed) to be sorted, and since $\max -\min \ne \infty$, or $\max -\min =\mathcal{O}\left(n\right)$, we will now start rolling from a smaller index, until the higher index is reached. Now, unrestrictive rolling can be thought of like a linear search, where the ball checks for each hole one by one in a sequential manner. The same unrestricted rolling can be replaced by binary search, wherein the middle hole of the max and min is considered initially, and based on the suitability of the hole, i.e., whether the radius of the hole is greater than or less than that of the ball, the next hole is calculated. This is repeated for all the balls, representing all the entries of the list to be sorted, and thus Sorting is visualized as repeated Sorting.

2.3. k-Ary Sort

In k-ary Search, the list of data is divided into k parts and searched further by comparing elements such as the key, which is the target value subjected to supervision; that is, the element to be found concerning the middle elements of the list. If it is not found, one moves to Boolean-involving inequalities that quantitatively define the estimated position of the element to be searched. This can be considered as the general case of the family to which Binary search (2-ary search) and other searching algorithms like Ternary Search (3-ary search) belong. k-ary Search, being the generic member of all the possible $k\ge 1$ partition search, contains characteristics that are improvised as an intersection of the characteristics of all the members of the family. In this generic search, the chunk of data is divided into k equal (probably) parts, with potent, $k-1$ indices that serve as middle points or points of supervision for the search. The generalized equation of one such point of supervision, relating to the initial diametric is

$$\mathrm{Mid}{\mathrm{Index}}_{\lambda }=\ell +\lambda \times {\displaystyle \frac{\sqcap -\ell }{k}}$$

where,

$$\ell ,\sqcap \equiv \mathrm{lower}\mathrm{bound},\mathrm{upper}\mathrm{bound}$$

It works on the principle of Divide and Conquer, where the whole chunk is divided into smaller sub-parts, and solved further. Algorithm 1 shows the Pseudocode for the k-ary Search Algorithm.

Algorithm 1 Pseudocode for the k-ary Search

Require:  ${\mathcal{L}}_n\ni {\mathcal{L}}_i=$i’th entry in the list, and the key, $\mathtt{KEY}$ Ensure:  $i\ni {\mathcal{L}}_i=\mathtt{KEY}$ or $-1$ if not found   1: function k-ary Search(${\mathcal{L}}_n,k,\ell ,\sqcap ,\mathtt{KEY}$)   2:     if $\sqcap \ge \ell$ then                        ▹Search space is valid if upper bound ≥ lower bound   3:         Initialize a dynamic array $\mathcal{M}$ to store the mid indices of partitions   4:         for $i=1$ to $k-1$ do                           ▹Compute $k-1$ mid points for the interval   5:            $\mathcal{M}\leftarrow \ell +i\times {\displaystyle \frac{\sqcap -\ell }{k}}$   6:         end for   7:         for $i=0$ to $\left|\mathcal{M}\right|-1$ do               ▹Check if KEY matches any of the mid elements   8:            if ${\mathcal{L}}_{{\mathcal{M}}_i}=\mathtt{KEY}$ then   9:                return ${\mathcal{M}}_i$                                                  ▹Return the index if match found 10:            end if 11:         end for 12:         for $i=0$ to $\left|\mathcal{M}\right|-1$ do               ▹Search left partition if mid is greater than KEY 13:            if ${\mathcal{L}}_{{\mathcal{M}}_i}>\mathtt{KEY}$ then 14:                return k-ary Search(${\mathcal{L}}_n,k,\ell ,{\mathcal{M}}_i-1,\mathtt{KEY}$) 15:            end if 16:         end for 17:         for $i=0$ to $\left|\mathcal{M}\right|-1$ do                  ▹Search right partition if mid is less than KEY 18:            if ${\mathcal{L}}_{{\mathcal{M}}_i}<\mathtt{KEY}$ then 19:                return k-ary Search(${\mathcal{L}}_n,k,{\mathcal{M}}_i+1,\sqcap ,\mathtt{KEY}$) 20:            end if 21:         end for 22:     end if 23:     return −1                                        ▹If search interval is invalid or KEY not found 24: end function

Now, some of the important metrics regarding this k-ary Search Algorithm are as follows:

• The worst-case time complexity of the k-ary searching algorithm will be $\mathcal{T}\left(n\right)=\left(k-1\right)\times {\log }_{k}n+\mathcal{O}\left(k\right)$, which occurs if the target element is present in the indices involving bounds; that is, the starting and the ending indices.
• The best-case time complexity is $\mathcal{T}\left(n\right)=\mathsf{\Omega }\left(1\right)$, which occurs if the target element is present at any of the mid indices.
• The average-case time complexity is $\mathcal{T}\left(n\right)=\mathsf{\Theta }\left({\log }_{k}n\right)$

If the key is present somewhere in the list, mathematically,

$${\gamma }_{\mathrm{total}}=1\times {\gamma }_1+2\times {\gamma }_2+3\times {\gamma }_3+4\times {\gamma }_4+\dots +{\log }_{k}n\times {\gamma }_{{\log }_{k}n}=\sum _{i=1}^{{\log }_{k}n}i\times {\gamma }_i$$

where, ${\gamma }_k$ indicates a number of elements that require a total of k comparisons, which is equal to $k^{k-1}$ Now,

$$\begin{array}{cc}\hfill {\gamma }_{\mathrm{total}}& =1\times {\gamma }_1+2\times {\gamma }_2+3\times {\gamma }_3+4\times {\gamma }_4+\dots +{\log }_{k}n\times {\gamma }_{{\log }_{k}n}\hfill \\ \hfill {\gamma }_{\mathrm{total}}& =k^{{\log }_{k}n}\times \left({\log }_{k}n-1\right)+1\hfill \end{array}$$

Now,

$${\gamma }_{\mathrm{average}}={\displaystyle \frac{k^{{\log }_{k}n}\times \left({\log }_{k}n-1\right)+1}{n+1}}={\displaystyle \frac{n\times \left({\log }_{k}n-1\right)+1}{n+1}}$$

So,

$${\mathcal{T}\left(n\right)}_{\mathrm{average}}=\mathsf{\Theta }\left({\displaystyle \frac{n\times \left({\log }_{k}n-1\right)+1}{n+1}}\right)\approx \mathsf{\Theta }\left({\log }_{k}n\right)$$

If sorting was sought in terms of the generic k-ary Search, time, as per the computational complexities, will be

$$\mathcal{T}\left(n\right)={\log }_{k}n+{\log }_k\left(n-1\right)+{\log }_k\left(n-2\right)+\dots +{\log }_{k}1$$

which can be further delineated as

$$\mathcal{T}\left(n\right)={\log }_k\left(\prod _{i=0}^{n-1}\left(n-i\right)\right)={\log }_k\left(n!\right)$$

(5)

Now, as mentioned earlier, there exist numerous approximations for this general factorial. Here, by making use of the “Very Accurate Approximations for the Factorial Function” by Necdet Batir [10], the result is sought. According to Batir,

$$n!\approx \sqrt[2]{2\pi }{n}^n{e}^{-n}\sqrt{n+{\displaystyle \frac{1}{6}}+{\displaystyle \frac{1}{72n}}-{\displaystyle \frac{31}{6480n^2}}-{\displaystyle \frac{139}{155520n^3}}+{\displaystyle \frac{9871}{6531840n^4}}}$$

Making use of the approximation from Equation (5),

$$\mathcal{T}\left(n\right)={\log }_k\left(\sqrt[2]{2\pi }{n}^n{e}^{-n}\right)+{\displaystyle \frac{{\log }_k\left(n+{\displaystyle \frac{1}{6}}+{\displaystyle \frac{1}{72n}}-{\displaystyle \frac{31}{6480n^2}}-{\displaystyle \frac{139}{155520n^3}}+{\displaystyle \frac{9871}{6531840n^4}}\right)}{2}}$$

(6)

which, on asymptotic notations, can be represented as in the order of $n{\log }_k\left(n\right)$

This follows the Search-o-Sort, as ${\displaystyle \frac{{\mathcal{T}}_{\mathrm{k-ary-search} }\left(n\right)}{{\mathcal{T}}_{\mathrm{k-ary-sort} }\left(n\right)}}={\displaystyle \frac{1}{n}}$.

2.4. Interpolation Sort

Interpolation Search is one of the extrapolations of the Binary Search. It is like searching for a page in a book, where each page is marked distinctly. Algorithm 2 shows the Pseudocode for the Interpolation Search Algorithm.

Now, some of the important metrics regarding this Interpolation Search Algorithm are as follows:

• The worst-case time complexity of the Interpolation Searching Algorithm will be $\mathcal{T}\left(n\right)=\mathcal{O}\left(n\right)$, which occurs if the target element is present in the indices involving bounds; that is, the starting and the ending indices.
• The Best-Case Time Complexity is $\mathcal{T}\left(n\right)=\mathsf{\Omega }\left(1\right)$, which occurs if the target element is present at any of the mid indices.
• In the average case, both cases are considered.

  (a)

  If the key is present in the list.

  (b)

  If it is not present in the list.

If the key is present somewhere in the list, it is assumed that the current search space is from 0 to $n+1$, and n keys are independently drawn from a uniform distribution. As all the elements in the data cluster are independent of each other, it is expected that the expected number of probes $\gamma$ is bound by a constant. So, the probability that at least one of them is equal to the $\phi$ will be

$$\xi ={\displaystyle \frac{\phi -\mathcal{L}\left[0\right]}{\mathcal{L}[n+1]-\mathcal{L}\left[0\right]}}$$

The probability that exactly $\psi$ of them is equal to $\phi$ will be

$${\xi }^{\prime }=\left(\begin{array}{c}n\\ \psi \end{array}\right){\xi }^{\psi }{(1-\xi )}^{n-\psi }$$

So, the number of keys expected to be less than or equal to $\phi$ will be

$$\sum _{\psi =1}^n{\xi }^{\prime }=\sum _{\psi =1}^n\left(\begin{array}{c}n\\ \psi \end{array}\right){\xi }^{\psi }{(1-\xi )}^{n-\psi }=\xi \times n$$

and variance of the following distribution will be

$${\sigma }^2=\sum _{\psi =1}^n\left(\psi -\left(\xi \times n\right)\right)\left(\begin{array}{c}n\\ \psi \end{array}\right){\xi }^{\psi }{(1-\xi )}^{n-\psi }=\xi \times \left(1-\xi \right)\times n$$

Since, $0<\xi <1$, so, $\xi \times \left(1-\xi \right)\le {\displaystyle \frac{1}{4}}$ and $\xi \times \left(1-\xi \right)\times n\le {\displaystyle \frac{n}{4}}$

$$\gamma =\sum _{i\ge 1}i\times {\xi }_r\left(\mathrm{Exactly}i\mathrm{probes}\mathrm{are}\mathrm{used}\right)=\sum _{i\ge 1}{\xi }_r\left(\mathrm{Atleast}i\mathrm{probes}\mathrm{are}\mathrm{used}\right)$$

Using bounding conditions of Chebyshev’s Inequality [11],

$$\gamma \le 2+\sum _{i\ge 3}{\displaystyle \frac{1}{4}}\times {\displaystyle \frac{1}{{\left(i-2\right)}^2}}=2+{\displaystyle \frac{{\pi }^2}{24}}\le 2.42$$

Let $\mathcal{T}\left(n\right)$ be the average number of probes needed to find a key in an array of size n. Let C be the expected number of probes needed to reduce the search space of size x to $\sqrt{x}$.

$$\mathcal{T}\left(n\right)=C^{\prime }+\mathcal{T}\left(\sqrt{n}\right)$$

where $C^{\prime }$ is the bound of the number of probes, C.

$$\mathcal{T}\left(n\right)\approx \mathsf{\Theta }\left({\log }_2\left({\log }_{2}n\right)\right)$$

If sorting is sought in terms of the Interpolation Search, time, as per the computational complexities, it will be

$$\mathcal{T}\left(n\right)={\log }_2{\log }_{2}n+{\log }_2{\log }_2\left(n-1\right)+{\log }_2{\log }_2\left(n-2\right)+\dots +{\log }_2{\log }_{2}1$$

which can be further delineated as

$$\mathcal{T}\left(n\right)={\log }_2\left(\prod _{i=0}^{n-1}{\log }_2\left(n-i\right)\right)$$

(7)

Since ${\log }_2\left(1\right)$, present at the rear end, will make the argument ${\prod }_{i=0}^{n-1}{\log }_2\left(n-i\right)$ as zero, and ${\log }_2\left(0\right)$ is undefined. Now, in practice, when it comes to searches in data having a single element, it will take a negligible amount of time, say $\epsilon$, such that $\epsilon \to 0$. In fact, it can be shown that $⌊{\displaystyle \frac{{\log }_{\beta }\left(x\right)}{{\log }_{\beta }\left(x+1\right)}}⌋\to 0$ as $x\to 1$ and $⌈{\displaystyle \frac{{\log }_{\beta }\left(x\right)}{{\log }_{\beta }\left(x+1\right)}}⌉\to 1$ as $x\to \infty$ for any base, $\beta$. So, its very evident from the observations that $0\le {\displaystyle \frac{{\log }_{\beta }\left(x\right)}{{\log }_{\beta }\left(x+1\right)}}\le 1\forall x\ge 1,x\in {\mathbb{R}}^{+}$. To normalize this, the Arithmetic Mean of the range is considered, and due to this assumption, it could be proclaimed that ${\displaystyle \frac{{\log }_{\beta }\left(x-1\right)}{{\log }_{\beta }\left(x\right)}}={\displaystyle \frac{1}{2}}$. Finally, ${\prod }_{i=0}^{n-1}{\log }_2\left(n-i\right)$ could be reformatted as

$$\prod _{i=0}^{n-1}{\log }_2\left(n-i\right)\approx \prod _{i=0}^{n-1}{\displaystyle \frac{{\log }_2\left(n\right)}{2^i}}\approx {\left({\log }_2\left(n\right)\right)}^n\times 2^{{\sum }_{i=0}^{n-1}\left(-i\right)}$$

Coming back to Sorting,

$$\mathcal{T}\left(n\right)={\log }_2({\left({\log }_2\left(n\right)\right)}^n\times 2^{{\sum }_{i=0}^{n-1}\left(-i\right)})$$

which can be further delineated as

$$\mathcal{T}\left(n\right)=n{\log }_2\left({\log }_2\left(n\right)\right)-\left({\displaystyle \genfrac{}{}{0pt}{}{n}{2}}\right)$$

A tighter bound to this method could be evicted by making use of the Incomplete Gamma Function. To recall, for Interpolation Search,

$$\mathcal{T}\left(n\right)=\sum _{i=1}^n{\log }_2{\log }_2\left(i\right)$$

Now,

$${\log }_2{\log }_2\left(k\right)\le {\int }_k^{k+1}{\log }_2{\log }_2\left(i\right)\mathrm{d}i\le {\log }_2{\log }_2(k+1)$$

$$\Rightarrow \sum _{k=1}^n\left({\log }_2{\log }_2\left(k\right)\right)\le \sum _{k=1}^n\left({\int }_k^{k+1}{\log }_2{\log }_2\left(i\right)di\right)\le \sum _{k=1}^n\left({\log }_2{\log }_2(k+1)\right)$$

In practice, ${\log }_2{\log }_2\left(k\right)$, for $k=1$ will be undefined as ${\log }_2\left(1\right)=0$ mathematically, but in real-life instances of computation, ${\lim }_{k\to 1}{\log }_2\left(k\right)=\epsilon$$\ni \epsilon \to 0$.

$${\log }_2\left(\epsilon \right)+\sum _{k=2}^n\left({\log }_2{\log }_2\left(k\right)\right)\le \sum _{k=1}^n\left({\int }_k^{k+1}{\log }_2{\log }_2\left(i\right)di\right)\le \sum _{k=1}^n\left({log}_2{log}_2(k+1)\right)$$

$$\sum _{k=2}^n\left({\log }_2{\log }_2\left(k\right)\right)\le \sum _{k=1}^n\left({\int }_k^{k+1}{\log }_2{\log }_2\left(i\right)di\right)-{\log }_2\left(\epsilon \right)$$

$$\sum _{k=2}^n\left({\log }_2{\log }_2\left(k\right)\right)\le {\int }_1^{n+1}{\log }_2{\log }_2\left(x\right)\mathrm{d}x-{\log }_2\left(\epsilon \right)$$

$$\therefore \mathcal{T}\left(n\right)\le \left(\left(n+1\right){\log }_2{\log }_2(n+1)+\mathsf{\Gamma }\left(0,-{\log }_2\left(n+1\right)\right)-\mathsf{\Gamma }\left(0,-\epsilon \right)\right)-2{\log }_2\left(\epsilon \right)$$

where

$$\mathsf{\Gamma }(0,x)\approx {\displaystyle \frac{e^{-x}}{x+{\displaystyle \frac{1}{1+{\displaystyle \frac{1}{x+{\displaystyle \frac{2}{1+{\displaystyle \frac{2}{x+{\displaystyle \frac{3}{1+{\displaystyle \frac{3}{\ddots }}}}}}}}}}}}}}={\pi }_c$$

Algorithm 2 Pseudocode for the Interpolation Search

Require:  ${\mathcal{L}}_n\ni {\mathcal{L}}_i=$i’th entry in the list, and the key, $\mathtt{KEY}$ Ensure:  $i\ni {\mathcal{L}}_i=\mathtt{KEY}$ or $-1$ if not found   1: function Interpolation Search(${\mathcal{L}}_n,\mathtt{KEY}$)   2:     $\ell \leftarrow 0$                                          ▹Initialize the lower bound of the search interval   3:     $\sqcap \leftarrow \left|{\mathcal{L}}_n\right|-1$                                     ▹Initialize upper bound of the search interval   4:     while $\mathtt{KEY}$ not found do                         ▹Continue searching while KEY not found   5:         if $\sqcap <\ell$ then                                      ▹Search interval is invalid; terminate loop   6:            break   7:         end if   8:         $\mathcal{M}=\ell +(\mathtt{KEY}-{\mathcal{L}}_{\ell })\times {\displaystyle \frac{\sqcap -\ell }{{\mathcal{L}}_{\sqcap }-{\mathcal{L}}_{\ell }}}$                                               ▹Linear Interpolation   9:         if ${\mathcal{L}}_{\mathcal{M}}=\mathtt{KEY}$ then                                               ▹Return the index if match found 10:            return $\mathcal{M}$ 11:         end if 12:         if ${\mathcal{L}}_{\mathcal{M}}>\mathtt{KEY}$ then                                                     ▹KEY lies in the left partition 13:            $\sqcap =\mathcal{M}-1$ 14:         end if 15:         if ${\mathcal{L}}_{\mathcal{M}}<\mathtt{KEY}$ then                                                  ▹KEY lies in the right partition 16:            $\ell =\mathcal{M}+1$ 17:         end if 18:     end while 19:     return −1                                      ▹If search interval is invalid or KEY not found 20: end function

Lemma 1.

${\pi }_c$ is related to the bounds of the Exponential Integral, Ei $\left(x\right)={\int }_{t=-x}^{\infty }{\displaystyle \frac{e^{-t}}{t}}\mathrm{d}t$ as

$$1-{\displaystyle \frac{3x}{4}}\le {\int }_{-x}^{\infty }{\displaystyle \frac{e^{-t}}{t}}dt-\gamma +\ln \left(x\right)\le 1-{\displaystyle \frac{3x}{4}}+{\displaystyle \frac{11x^2}{36}}$$

where,

$$\gamma =\underset{n\to \infty }{\lim }\left(\sum _{k=1}^n\left({\displaystyle \frac{1}{k}}\right)-\ln \left(n\right)\right)$$

which is the Euler–Mascheroni constant.

Making use of Lemma 1,

$$-\left(1+{\displaystyle \frac{3x}{4}}+\gamma +\ln \left(-x\right)\right)-i\pi >{\pi }_c>-\left(1+{\displaystyle \frac{3x}{4}}+{\displaystyle \frac{11x^2}{36}}+\gamma +\ln \left(-x\right)\right)-i\pi$$

where, $i=\sqrt{-1}$.

So,

$${\left({\pi }_c\right)}_{\max }=-\left(1+{\displaystyle \frac{3x}{4}}+\gamma +\ln \left(-x\right)\right)-i\pi$$

Now,

$$\mathsf{\Gamma }\left(0,-{\log }_2\left(n+1\right)\right)=\left({\displaystyle \frac{e^{{\log }_2\left(n+1\right)}}{-{\log }_2\left(n+1\right)+{\displaystyle \frac{1}{1+{\displaystyle \frac{1}{-{\log }_2\left(n+1\right)+{\displaystyle \frac{2}{1+{\displaystyle \frac{2}{-{\log }_2\left(n+1\right)+{\displaystyle \frac{3}{\ddots }}}}}}}}}}}}\right)$$

and

$$\mathsf{\Gamma }\left(0,-\epsilon \right)=\left({\displaystyle \frac{e^{\epsilon }}{-\epsilon +{\displaystyle \frac{1}{1+{\displaystyle \frac{1}{-\epsilon +{\displaystyle \frac{2}{1+{\displaystyle \frac{2}{-\epsilon +{\displaystyle \frac{3}{\ddots }}}}}}}}}}}}\right)$$

So, the maximum value of

$$\left({\displaystyle \frac{e^{{\log }_2\left(n+1\right)}}{-{\log }_2\left(n+1\right)+{\displaystyle \frac{1}{1+{\displaystyle \frac{1}{-{\log }_2\left(n+1\right)+{\displaystyle \frac{2}{1+{\displaystyle \frac{2}{-{\log }_2\left(n+1\right)+{\displaystyle \frac{3}{\ddots }}}}}}}}}}}}\right)$$

will be

$$-\left(1+{\displaystyle \frac{3\left(-{\log }_2\left(n+1\right)\right)}{4}}+\gamma +\ln \left(-\left(-{\log }_2\left(n+1\right)\right)\right)\right)-i\pi$$

and that of

$$\max \left({\displaystyle \frac{e^{\epsilon }}{-\epsilon +{\displaystyle \frac{1}{1+{\displaystyle \frac{1}{-\epsilon +{\displaystyle \frac{2}{1+{\displaystyle \frac{2}{-\epsilon +{\displaystyle \frac{3}{\ddots }}}}}}}}}}}}\right)=-\left(1+{\displaystyle \frac{3\left(-\epsilon \right)}{4}}+\gamma +\ln \left(-\left(-\epsilon \right)\right)\right)-i\pi$$

So, from Equation (7),

$$\sum _{k=2}^n\left({\log }_2{\log }_2\left(k\right)\right)=\mathcal{O}\left(\left(n+1\right){\log }_2{\log }_2(n+1)\right)=\mathcal{O}\left(n{\log }_2{\log }_2\left(n\right)\right)$$

(8)

This follows the Search-o-Sort, as ${\displaystyle \frac{{\mathcal{T}}_{\mathrm{interpolation}-\mathrm{search}}\left(n\right)}{{\mathcal{T}}_{\mathrm{interpolation}-\mathrm{sort}}\left(n\right)}}={\displaystyle \frac{1}{n}}$.

NOTE: A general interpolation paradigm is $\mathcal{M}=\ell +\left({\displaystyle \frac{{(\mathtt{KEY}-{\mathcal{L}}_{\ell })}^p}{{({\mathcal{L}}_{\sqcap }-{\mathcal{L}}_{\ell })}^p}}\right)·(\sqcap -\ell )$. As per the seminal work by Gonnet et al. [1]; they considered $p=1$ (linear interpolation). $p>1$ skews the probe towards the upper index, while $0<p<1$ skews the probe towards the lower index. This does not affect the computational complexity (asymptotically) of Interpolation Search (non-linear), and thus the Search-o-Sort theory holds.

2.5. Extrapolation Sort

In the literature, there are no algorithmic developments that (explicitly) relate to Extrapolation Searching, but for evaluation of the proposed Search-o-Sort Algorithm, a logical development is made in Algorithm 3. It searches for the key beyond the learned range of the sorted dataset by extrapolating the (likely) position of the target.

Now, some of the important metrics regarding Extrapolation Search Algorithm are as follows:

• The worst-case time complexity of the Extrapolation Searching Algorithm will be $\mathcal{T}\left(n\right)=\mathcal{O}\left(n\right)$, which occurs if the data are highly skewed, or the extrapolated estimate repeatedly fails to converge toward the target, thus degrading to a sequential or linear-like search.
• The best-case time complexity is $\mathcal{T}\left(n\right)=\mathsf{\Omega }\left(1\right)$, which occurs if the target element lies near the extrapolated index on the first estimation and is found without any iterative refinement.
• In the average case, both conditions are considered:

  (a)

  If the key is present in the list.

  (b)

  If it is not present in the list.

Algorithm 3 Pseudocode for the Extrapolation Search

Require:  ${\mathcal{L}}_n\ni {\mathcal{L}}_i=$i’th entry in the list, and the key, $\mathtt{KEY}$ Ensure:  $i\ni {\mathcal{L}}_i=\mathtt{KEY}$ or $-1$ if not found   1: function Extrapolation Search(${\mathcal{L}}_n,\mathtt{KEY}$)   2:     $\ell \leftarrow 0$                                               ▹Initialize lower bound of the search interval   3:     $\sqcap \leftarrow \left|{\mathcal{L}}_n\right|-1$                                   ▹Initialize upper bound of the search interval   4:     if ${\mathcal{L}}_{\ell }={\mathcal{L}}_{\sqcap }$ then                                              ▹Check if all elements are the same   5:         if ${\mathcal{L}}_{\ell }=\mathtt{KEY}$ then                                               ▹Return index if the KEY matches   6:            return ℓ   7:         else   8:            return −1                                                     ▹KEY not found in constant array   9:         end if 10:     end if 11:     $\mathcal{M}\leftarrow \ell +(\mathtt{KEY}-{\mathcal{L}}_{\ell })\times {\displaystyle \frac{\sqcap -\ell }{{\mathcal{L}}_{\sqcap }-{\mathcal{L}}_{\ell }}}$                                  ▹Initial (extrapolated) guess 12:     if $\mathcal{M}<\ell \mathbf{or}\mathcal{M}>\sqcap$ then            ▹Check for extrapolated index out of bounds 13:         return −1                                                ▹Extrapolated outside valid interval 14:     end if 15:     while $\mathtt{KEY}$ not found do                                   ▹Repeat search until KEY is found 16:         if $\sqcap <\ell$ then        return −1                    ▹Search interval is invalid; exit loop 17:            break 18:         end if 19:         $\mathcal{M}\leftarrow \ell +(\mathtt{KEY}-{\mathcal{L}}_{\ell })\times {\displaystyle \frac{\sqcap -\ell }{{\mathcal{L}}_{\sqcap }-{\mathcal{L}}_{\ell }}}$                          ▹Recompute extrapolated index 20:         if $\mathcal{M}<\ell \mathbf{or}\mathcal{M}>\sqcap$ then              ▹Check bounds for new extrapolated index 21:            return −1                                                ▹Extrapolated outside valid interval 22:         end if 23:         if ${\mathcal{L}}_{\lfloor \mathcal{M}\rfloor }=\mathtt{KEY}$ then                                                            ▹Return if KEY matches 24:            return $\lfloor \mathcal{M}\rfloor$ 25:         else if ${\mathcal{L}}_{\lfloor \mathcal{M}\rfloor }>\mathtt{KEY}$ then                                    ▹Narrow search to left partition 26:            $\sqcap \leftarrow \lfloor \mathcal{M}\rfloor -1$ 27:         else                                                               ▹Narrow search to right partition 28:            $\ell \leftarrow \lfloor \mathcal{M}\rfloor +1$ 29:         end if 30:     end while 31:     return −1                                       ▹If search interval is invalid or KEY not found 32: end function

If the key is present somewhere in the list, it is assumed that the search space is uniformly distributed over $[0,n+1]$, and n keys are independently drawn from a linear distribution. The goal is to predict the index outside the bounds where the value might lie using extrapolation rather than interpolation. The Apropos Interpolation Search, $\mathcal{T}\left(n\right)\approx \mathsf{\Theta }\left({\log }_2\left({\log }_{2}n\right)\right)$ is obtained by further calculations (similar to its predecessor). Therefore, this follows the Search-o-Sort, as ${\displaystyle \frac{{\mathcal{T}}_{\mathrm{extrapolation}-\mathrm{search}}\left(n\right)}{{\mathcal{T}}_{\mathrm{extrapolation}-\mathrm{sort}}\left(n\right)}}={\displaystyle \frac{1}{n}}$.

2.6. Jump Sort

Jump Search is a searching technique [9] that is well defined for sets with the existence of some sort of order prevailing between them. Its course of action is quite simple, and involves checking for every element in the list ${\mathcal{L}}_{k\alpha }$, for all $k\in \mathbb{N}$, with $\alpha$ as the evicted block size, until and unless the match is found, larger than the key of supervision. To find the exact position of the key of supervision in the list, a 1-ary search is performed on the sublist, $\left[{\mathcal{L}}_{\left(k-1\right)\alpha }:{\mathcal{L}}_{\alpha }\right]$. The block size to be evicted should be of appropriate optimality. Accordingly, $\sqrt[2]{n}$ is one such point, with n being the cardinality of the List $\mathcal{L}$. Algorithm 4 shows the Pseudocode for the Jump Search Algorithm.

Algorithm 4 Pseudocode for the Jump Search

Require:  ${\mathcal{L}}_n\ni {\mathcal{L}}_i=$i’th entry in the list, and the key, $\mathtt{KEY}$ Ensure:  $i\ni {\mathcal{L}}_i=\mathtt{KEY}$ or $-1$ if not found   1: function Jump Search(${\mathcal{L}}_n,\mathtt{KEY}$)   2:     $a\leftarrow 0$                                                                                                                    ▹Initialize start of block   3:     $b\leftarrow ⌊\sqrt{n}⌋$                                                                                                               ▹Initialize end of block   4:     while ${\mathcal{L}}_{\min (b,n)-1}<\mathtt{KEY}$ do                                       ▹Jump forward while block’s end is less than KEY   5:         $a\leftarrow b$                                                                                         ▹Move start to end of previous block   6:         $b\leftarrow b+⌊\sqrt{n}⌋$                                                                                                  ▹Move end to next block   7:         if $a\ge n$ then                                                              ▹If start exceeds array bounds, KEY not found   8:            return −1   9:         end if 10:     end while 11:     while ${\mathcal{L}}_a<\mathtt{KEY}$ do                                                             ▹Linear search within the identified block 12:         $a\leftarrow a+1$ 13:         if $a=\min (b,n)$ then                                               ▹If end of block reached without finding KEY 14:            return −1                                                                                                                    ▹$\mathtt{KEY}$ not found 15:         end if 16:     end while 17:     if ${\mathcal{L}}_a=\mathtt{KEY}$ then                                                                                                   ▹KEY found at index a 18:         return a 19:     else 20:         return −1                                                                                                                       ▹$\mathtt{KEY}$ not found 21:     end if 22: end function

Now, some of the important metrics regarding this Jump Search Algorithm are as follows:

• In the worst-case scenario, one has to complete ${\displaystyle \frac{n}{m}}$ jumps (n being the cardinality, m being the size of the block to be evicted) and if the last checked value is greater than the element to be searched for, it performs $m-1$ comparisons more for a linear search. Hence, on the whole, the number of comparisons in the worst case will be $\left(\left({\displaystyle \frac{n}{m}}\right)+m-1\right)$. So, the worst-case complexity will be $\mathcal{O}\left(\sqrt[2]{n}\right)$.
• The best-case complexity can be obtained simply from the number of comparisons that need to be performed for supervision, $\eta =\left(\left({\displaystyle \frac{n}{m}}\right)+m-1\right)$. Now, ${\displaystyle \frac{\mathrm{d}\eta }{\mathrm{d}m}}={\displaystyle \frac{-n}{m^2}}+1$. ${\displaystyle \frac{\mathrm{d}\eta }{\mathrm{d}m}}$ will be minimum when $m=\sqrt{n}$. With that being said, the best-case complexity becomes $\mathsf{\Omega }\left(1\right)$.
• The average-case complexity for this Searching Technique is abruptly equal to the worst-case complexity, $\mathsf{\Theta }\left(\sqrt[2]{n}\right)$.

If sorting was sought in terms of Jump Search, the time, as per the computational complexities, will be

$$\mathcal{T}\left(n\right)=\sqrt{n}+\sqrt{n-1}+\sqrt{n-2}+\sqrt{n-3}+\dots +\sqrt{1}$$

Before, moving further, let us consider the following corroboration [12]

Claim. 

$\int \phi \left(x\right)\times \varphi \left(x\right)\mathrm{d}\mu \le \sqrt[\zeta ]{\int {\phi }^{\zeta }\left(x\right)\mathrm{d}\mu }\times \sqrt[\varsigma ]{\int {\varphi }^{\varsigma }\left(x\right)\mathrm{d}\mu }$$\forall \phi \left(x\right)\in {\mathbb{R}}^{+}$ & $\varphi \left(x\right)\in {\mathbb{R}}^{+}$

Proof. 

Now, firstly, let us consider a probability distribution, $\mathcal{P}$, and function $\psi \left(x\right)$, which is $\mathcal{P}$-measurable. Now, according to Jensen’s Inequality [13],

$$\int \psi \left(x\right)\mathrm{d}x\le {\left(\int {\psi }^{\zeta }\left(x\right)\mathrm{d}x\right)}^{{\displaystyle \frac{1}{\zeta }}}$$

Now, let us consider the measure, $\mu$, such that the density of the probability distribution, $\mathcal{P}$, concerns the measure $\propto {\varphi }^{\varsigma }\left(x\right)$.

$$\therefore \delta \mathcal{P}={\displaystyle \frac{\varphi \left(x\right)}{\int {\varphi }^{\varsigma }\left(x\right)\mathrm{d}\mu }}\delta \mu$$

Let us consider $\psi \left(x\right)=\phi \left(x\right)\times {\varphi }^{1-\varsigma }\left(x\right)$, and since ${\displaystyle \frac{1}{\zeta }}+{\displaystyle \frac{1}{\varsigma }}=1$

$$\int \phi \left(x\right)\times \varphi \left(x\right)\mathrm{d}\mu =\left(\int {\varphi }^{\varsigma }\left(x\right)\mathrm{d}\mu \right)\int \left(\phi \left(x\right)\times {\varphi }^{1-\varsigma }\left(x\right)\right)\left({\displaystyle \frac{\varphi \left(x\right)}{\int {\varphi }^{\varsigma }\left(x\right)\mathrm{d}\mu }}\right)\mathrm{d}\mu$$

Further,

$$\int \phi \left(x\right)\times \varphi \left(x\right)\mathrm{d}\mu \le \left(\int {\varphi }^{\varsigma }\left(x\right)\mathrm{d}\mu \right)\sqrt[\zeta ]{\left(\int \left({\phi }^{\zeta }\left(x\right)\times {\varphi }^{\zeta \times \left(1-\varsigma \right)}\left(x\right)\right)\left({\displaystyle \frac{\varphi \left(x\right)}{\int {\varphi }^{\varsigma }\left(x\right)\mathrm{d}\mu }}\right)\mathrm{d}\mu \right)}$$

Finally, it can be concluded that

$$\int \phi \left(x\right)\times \varphi \left(x\right)\mathrm{d}\mu \le \sqrt[\zeta ]{\int {\phi }^{\zeta }\left(x\right)\mathrm{d}\mu }\times \sqrt[\varsigma ]{\int {\varphi }^{\varsigma }\left(x\right)\mathrm{d}\mu }$$

   □

It is known that ${\int }_1^n{\displaystyle \frac{\mathrm{d}x}{x}}=\log \left(x\right)\forall n\ge 1$

By making use of the inequality, $\int \phi \left(x\right)\times \varphi \left(x\right)\mathrm{d}\mu \le \sqrt[\zeta ]{\int {\phi }^{\zeta }\left(x\right)\mathrm{d}\mu }\times \sqrt[\varsigma ]{\int {\varphi }^{\varsigma }\left(x\right)\mathrm{d}\mu }$, it can be said,

$${\int }_1^n{\displaystyle \frac{\mathrm{d}x}{x}}=\int \left(1\right)\times \left({\displaystyle \frac{1}{x}}\right)\mathrm{d}x\le \left(\sqrt[2]{{\int }_{x=1}^n\mathrm{d}x}\right)\times \left(\sqrt[2]{{\int }_{x=1}^n{\left({\displaystyle \frac{1}{x}}\right)}^2\mathrm{d}x}\right)=\sqrt[2]{n}-{\displaystyle \frac{1}{\sqrt[2]{n}}}$$

which can be reformatted as $\log n\le \sqrt[2]{n}-{\displaystyle \frac{1}{\sqrt[2]{n}}}$. Now, for high values of n, or in just terms, when, $n\to \infty$, $\log n\approx \sqrt[2]{n}$ will give us a good bound.

Now, coming back to Sorting,

$$\mathcal{T}\left(n\right)=\sum _{i=0}^{n-1}\sqrt[2]{n-i}=\sum _{i=0}^{n-1}\log \left(n-i\right)=\log \left(\prod _{i=0}^{n-1}\left(n-i\right)\right)$$

(9)

which can be further delineated on asymptotic notations, and can be represented as in the order of $n\log \left(n\right)$ or $n\sqrt{n}$, (Equation (9)) to stay in accordance with the assumption mentioned above.

This follows the Search-o-Sort Theory, as ${\displaystyle \frac{{\mathcal{T}}_{\mathrm{jump}-\mathrm{search}}\left(n\right)}{{\mathcal{T}}_{\mathrm{jump}-\mathrm{sort}}\left(n\right)}}={\displaystyle \frac{1}{n}}$.

3. Conclusions

This Search-o-Sort theory is a bridge between Sorting and Searching Algorithms which seeks to merge the notions constructively. In the previous works, the minimum time $\mathcal{T}\left(n\right)$ that could be achieved was sought to be $n{\log }_{2}n$, which was attainable by making use of Binary Search. Now, in this research, its domain is extended to a more generic one. Sorting enhanced with k-ary search, which gave a minimal worst-case time complexity of $n{\log }_{k}n$ is introduced. Further, we made use of the Interpolation Search, which indeed comes with some requisites, but still, assuming that the ample requirements being provided, it managed to fetch a computational time of the order $n{\log }_2\left({\log }_2\left(n\right)\right)-\left({\displaystyle \genfrac{}{}{0pt}{}{n}{2}}\right)$. Further, the method was improvised with the notions of Incomplete Gamma Function, or digamma function, to obtain a Computational Advanced Complexity, in terms of the Big—Oh asymptotic as, $\mathcal{O}\left(n{\log }_2{\log }_2\left(n\right)\right)$. Lastly, we made use of Jump Search, which comes with a computational complexity of the order $\sqrt{n}$, which when implemented in Sorting, gave a computational complexity of ${\sum }_{i=0}^{n-1}\left({\int }_{x=1}^{x=n-i}\left({\displaystyle \frac{\mathrm{d}x}{x}}\right)\right)$. Some scopes of further research that could be considered are as follows:

• A tighter bound, if possible, could be searched for ${\log }_2\left({\prod }_{i=0}^{n-1}{\log }_2\left(n-i\right)\right)$.
• An even tighter bound, if possible, could be searched for ${\sum }_{i=0}^{n-1}\sqrt[2]{n-i}$.

Figure 3 draws a comparative graphical study of the algorithms that are emphasized as a primary part of the research.