You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Sorting Series (a kind of discrete optimization problem)
4
-
lies at the center of Computer Science and Algorithms
5
-
because of its many uses
3
+
Sorting Series, which is also a **kind of discrete optimization problem** (i.e the permutation function `p` of `0..N-1` which **maximizes**`0*a[p[0]]+1*a[p[1]]+..+(N-1)*a[p[N-1]]` is the **permutation which sorts the array `a` in ascending order** that is `a[p[0]] <= a[p[1]] <= .. <= a[p[N-1]]`), lies at the center of Computer Science and Algorithms because of its many uses.
(number/count based=> O(N) complexity) (see below)
20
+
1. In the Block case, the whole array is available at once
21
+
for this case many algorithms are known (comparison-based=> `O(N^2)`, `O(NlogN)` complexities) and (number/count based=> `O(N)` complexity) (see below)
22
+
23
+
2. In the Adaptive/Online case, the input series is
24
+
accesed one at a time (for example an time-input signal). In this case some of the previous algorithms can be transformed to work adaptively
29
25
30
-
* In the Adaptive/Online case, the input series is
31
-
accesed one at a time (for example an time-input signal)
32
-
In this case some of the previous algorithms can be transformed to work adaptively
26
+
Apart from that, there are algorithms (like Dynamic Lists, Dynamic Heaps and Balanced Trees, Tries, eg AVL Trees)
27
+
which keep an input sequence always in a 'sorted' state (with each new input) with relatively low complexity (eg `O(logN)`)
do not use comparisons (of any kind) between elements,
50
-
but instead use their arithmetic/counting/statistical properties
39
+
* Statistics-based sorting algorithms (CountingSort, BucketSort, RadixSort, etc..), do not use comparisons (of any kind) between elements, but instead use their arithmetic/statistical properties
51
40
52
-
This makes possible algorithms which can sort in linear O(N) time (the fastest possible)
41
+
This makes possible algorithms which can sort in linear `O(N)` time (the fastest possible)
53
42
However these algorithms have some limitations (eg only Integers, or special kinds of Numbers)
54
43
55
-
Is O(N) sorting possible for arbitrary random numbers??
44
+
45
+
> Is `O(N)` sorting possible for arbitrary random numbers??
46
+
47
+
48
+
Computing the value of a certain number `n` requires approximately `O(logn)`*"primitive digit"* operations. Since (statisticaly) the **values of numbers in a list is correlated to the size of the list itself** (i.e a list of size `N` contains random numbers in the range `0..N` with **very high probability** over lists of same size for numbers in a given range), one then has an overall complexity of `O(NlogN)` even for arithmetic-based sorting algorithms (see for example *"what is the true complexity of radix sort?"*).
49
+
50
+
> Classical algorithms for integer sorting require **assumptions about the size of the integers** to be sorted, or else have a **running time dependent on the size**.
51
+
52
+
-- [Sorting in Linear Time?](https://www.cs.unc.edu/~plaisted/comp550/linear%20time%20sorting.pdf)
53
+
54
+
However the catch here is that same holds for comparing arbitrary numbers, computationaly one has to compare `primitive digit` by `primitive digit` in sequence on average, hence an additional `O(logn)` complexity for comparison-based algorithms.
55
+
56
+
57
+
> Is `O(NlogN)` complexity a kind of *strict base line* for this computational model??
58
+
59
+
According to Knuth's theoretical lower bound theorem for general (comparison) sorting algorithms (note `O(logN!) = O(NlogN)`): the `O(NlogN)` bound is asymptoticaly tight (see also [information-theoretic lower bound for comparison sorts](http://www.inf.fh-flensburg.de/lang/algorithmen/sortieren/lowerbounden.htm) ie Ω(NlogN) ).
60
+
61
+
62
+
A summary of various sorting/searching algorithms can be found in [this pdf](http://epaperpress.com/sortsearch/download/sortsearch.pdf)
> __Algorithms as a technology__ Suppose computers were infinitely fast and memory was free. Would you have any reason to study algorithms? The answer is yes, if for no other reason than that you would still like to demonstrate that your solution method terminates and does so with the correct answer.
81
-
...Of course, computers may be fast but not infinitely fast and memory may be cheap but not completely free. Computing time is therefore a bounded resource, and so is space in memory. These resources should be used wisely and algorithms that are efficient in terms of time and space will help you do so.
82
-
This demostrates that algorithms, like computer hardware, are a __technology__ . Total system performance depends on choosing efficient algorithms as much as choosing fast hardware. Just as rapid advances are being made in other computer technologies, they are being made in algorithms as well. (__Introduction to algorithms, 2nd Ed. Cormen,Leiserson,Rivest,Stein__)
83
-
84
-
85
-
112
+
...Of course, computers may be fast but not infinitely fast and memory may be cheap but not completely free. Computing time is therefore a bounded resource, and so is space in memory. These resources should be used wisely and algorithms that are efficient in terms of time and space will help you do so.
113
+
This demostrates that algorithms, like computer hardware, are a __technology__ . Total system performance depends on choosing efficient algorithms as much as choosing fast hardware. Just as rapid advances are being made in other computer technologies, they are being made in algorithms as well. (__Introduction to algorithms, 2nd Ed. Cormen,Leiserson,Rivest,Stein__)
114
+
115
+
116
+
117
+
__Algorithms as a "green" technology__
118
+
86
119
Additionaly, every operation/instruction a computer performs has an energy consumption cost. So an efficient algorithm saves energy!
87
120
An efficient algorithm performs a computation by trying to use the resources in the best possible manner, so effectively uses energy in the best possible manner.
88
121
Where does energy come from? It comes from burning coal (mainly).
89
122
So there you have it, efficient code is ecological!
90
-
Better start learning your [complexity](http://en.wikipedia.org/wiki/Computational_complexity_theory) soon.
123
+
Better start learning your [complexity](http://en.wikipedia.org/wiki/Computational_complexity_theory) soon.
0 commit comments