Sorting an array without using conditional statements

Immediately I warn you that this article will be an alternative version of this one . Yes, I can smell it straightforward as everyone rushes at once to criticize me, but, guys, the algorithm of the representations in the solution is not optimal. The comments offered even simpler algorithms on python. On python it is enough to write:

array.sort() 

And that's all. Who needs any algorithm at all? The task was set to a limit of 0 to 100, we are not lazy, we will do it in a general form, for any values ​​and with repetitions of numbers. A little thought, came here to this decision:


And now, let's look at what I wrote here.

In general, the problem is to find the minimum and maximum, since we can not use the comparison, then:
')

 public static int max(int a, int b) { int i; for (i = 0; i < a - Math.abs(b);) { return a; } return Math.abs(b); } 

If B modulo is more than A, then the cycle simply fails and returns. This is a fairly simple solution. Without the "great" mathematical formulas. Simple and clear. And also: why do I take on the module? This is caused by the sort method I use.

The original article uses a sort of "with a flag" (if I understood correctly). Performing such a sorting in the worst case is O (N ^ 2) (or close to it), which is not good.

This method (I don’t remember its name, it’s not lazy to look for this royal business ) decides in O (N) even though the numbers will be repeated.

 for (i = 0; i < NUM_ELEMENT; i++) { sortArray[arrayForSort[i] + maxNum]++; } 

The essence of sorting is that when the array is filled, it sorts itself. We represent the value as an index and increase the number of items in this index.


As it turned out (whether I am Krivorukov), arrays are created from 0 to N and as I did not try to make from -N to N, without success. Therefore, we make the offset, so we are looking for a maximum with the module. Then we simply reflect relative to 0 and we get a range of indices into which all elements except the boundary one exactly fit, so +1.

 sortArray = new int[maxNum * 2 + 1]; . . . sortArray[arrayForSort[i] + maxNum]++; . . . System.out.print(i - maxNum + " "); 

I have it all. I performed the task, while optimizing the process and presenting my vision of the solution to this problem.