There are some terms that can be used to rate code. accuracy, efficiency, standby, reuse testability and few others lens measurable metrics come to mind.
Efficiency is not really a problem here, and due to the simplicity of the algorithm, this is not true. However, it was difficult to verify that the code is correct because it is almost unreadable. It is also not reusable at all, since the sorting method is embedded inline and therefore not testable.
Let's review the code in detail for this little overview.
The outer one while
The loop is only terminated if srcPos == arrLen  1
, This can only happen if srcPos
will not be set 0
which happens only if two elements were out of order. So if we have srcPos == arrLen  1
all elements are less than or equal to their predecessors and the array is sorted.
This was a reverse goal. Although it's already slow, I mistakenly read the code by mistake (see next section) and read:
...
var srcPos = 0, dstPos, tmp; // declare variables
while (srcPos <arrLen1) {
dstPos = srcPos + 1;
while (dstPosarr[dstPos]{tmp = arr[srcPos]arr[srcPos]= arr[dstPos]arr[dstPos]= tmp; srcPos = 0; break}
// if (arr[srcPos]> arr[dstPos]{arr[srcPos]^ = arr[dstPos]arr[dstPos]^ = arr[srcPos]arr[srcPos]^ = arr[dstPos]srcPos = 0; break}
// if (arr[srcPos]> arr[dstPos]{arr[srcPos]+ = arr[dstPos]arr[dstPos]= arr[srcPos]arr[srcPos]arr[srcPos]+ = arr[dstPos]srcPos = 0; break}
dstPos ++;
}
srcPos ++; // Whoops!
}
...
This is even worse as we receive many unnecessary comparisons. See "But that can be made worse".
It's getting slow …
Your code will be restarted at each inversion and ends with $ mathcal O (n ^ 3) $, That's bad, but it gets worse.
But that can be made worse
Just increase src
just in the outer while
, Here is the analysis for the case:
The worst runtime we can get concerns an inverse array, e.g. [5,4,3,2,1]
:
[5,4,3,2,1]
[4,5,3,2,1]
[3,5,4,2,1]
[2,5,4,3,1]
[1,5,4,3,2]
...
To the $ n $ Elements we need $ 1 $ Comparison to move the largest element to the second position $ 2 $ Elements to move the second largest to the third, and so on. In summary, we have $$ 1 + 2 + lpoints + (n2) + (n1) = frac {n (n1)} {2} $$ Compare to bring the smallest value to the front. In contrast to bubble sorting we are always reset srcPos
to zero. Therefore, the second smallest value does not take less time to get to the front:
[1,4,5,3,2]  4 comparisons for 1, 1 comparison for 54
[1,3,5,4,2]  4 comparisons for 1, 2 comparisons for 45, 43
[1,2,5,4,3]  4 comparisons for 1, 3 comparisons for 35, 34, 32
Although we should only be able to look at the subarray at index one, we should always I have the first 4 comparisons. So for the second element we have
$$ ((n1) + 1) + ((n1) +2) + l points + ((n1) + (n3)) + ((n1) + (n 2)))
= (n1) (n2) + frac {(n1) (n2)} {2} $$
Comparisons. For the rest it is similar:
[1,2,5,4,3]
[1,2,4,5,3]  4 comparisons for 1, 3 comparisons 2, 1 comparison for 54
[1,2,3,5,4]  4 comparisons for 1, 3 comparisons 2, 2 comparison for 45
43
When we have completed the introduction, we get
$$ sum_ {i = 0} ^ n frac {(ni) (ni1)} {2} + (ni1) sum_ {j = 1} ^ i (nj) $$
that is inefficient enough. Good work there :).
legibility Really suffers because the swap logic is in a single line. In addition, there are several values with short names that do not refer to your algorithm at all.
Also, we can not use sorting outside of this snippet. That prevents
 Sort more than one array
 custom sorting (eg vice versa, lexicographical, etc.)
 test
So let's do a function first:
Function slowSort (arr) {
var src = 0;
var least;
var tmp;
while (src <arr.length  1) {
dest = src + 1;
while (at least < arr.length) {
if(arr[src] > arr[dest]) {
temp = arr[dest];
arr[dest] = arr[src];
arr[src] = Temp;
src = 0;
break;
}
least ++;
src ++; // Put this on the outside to make it worse, but
// Remember to set `src = 1` instead.
}
}
}
This is much easier to read. We can now too
 sort several times
 Get improvements / speed regressions for each call page

add additional comparison methods, such as
Function slowSort (arr, comp) {...}
 exam the function
Always try to make your code reusable, verifiable and readable.