Talk:Sorting algorithm/Archive 3

Big-O should denote upper bounds, and Big-Omega denotes lower bounds. I realize that at least colloquially, people don't pay that much attention and say Big-O in all cases, often intending a meaning closer to that of Big-Theta (the conjunction of Big-O and Big-Omega), but that is incorrect usage and should be corrected on Wikipedia, or am I missing a semi-formal convention which standardizes that usage? At the very least the article on Big-O notation seems to agree with me at a quick glance.

"A fundamental limit of comparison sorting algorithms is that they require linearithmic time – O(n log n) – in the worst case"

"Comparison-based sorting algorithms (...) need at least O(n log n) comparisons for most inputs."

"These are all comparison sorts, and so cannot perform better than O(n log n) in the average or worst case."

Syrak (talk) 22:49, 16 November 2015 (UTC)

@Qwertyus:

I've reverted Qwertyus; my revert replaces the Ω() bound in favor of O(n).

Higher up in that section, the best average/worst case performance is described as O(nlogn).

These are all comparison sorts, and so cannot perform better than O(n log n) in the average or worst case.

There are strange scope of quantification issues.

Saying a sorting algorithm is O(nlogn) allows the execution with particular input to be less than nlogn; bubble sort taking n comparisons is not a surprise; it does not contradict the bound.

Some algorithms are strictly Θ(nlogn). Heapsort goes through all the motions no matter what. But that doesn't mean all sorting has such a lower bound.

Saying a sorting algorithm is Ω(nlogn) says it can never do better than nlogn. Bubblesort does better once in a while.

Throwing in "average case" or "worst case" muddies an order statistic.

Speaking of Ω() in the context of "worst case" is really speaking in terms of an upper bound (the worst case) rather than a lower bound.

The meaning of "average case" for many sorts is the same as "worst case". Yes, I know quicksort's worst case is a counterexample to that statement.

I don't see Ω() having the precision claimed.

Glrx (talk) 21:13, 30 November 2015 (UTC)

CLRS, Theorem 8.1 (3rd ed., p. 193):

Any comparison sort algorithm requires Ω(n log n) comparisons in the worst case.

This is exactly the bound we're trying to express: no algorithm can beat an n log n lower bound in its worst case. The theorem allows linear best cases (it doesn't concern them) and quadratic worst cases (since n² = Ω(n log n)). CLRS don't say much about the average case, except giving it as an exercise to proof that linear average case is impossible.

Our current formulation is in fact imprecise. A linear time algorithm still runs in O(n log n), so in that sense it doesn't perform any better. QVVERTYVS (hm?) 21:58, 30 November 2015 (UTC)

(e/c) I don't dispute that a sorting algorithm requires k * (nlogn) comparisons in the worst case.

I dispute that makes the algortithm complexity Ω(nlogn).

The CT definition of Ω() does not have the notion of worst case in it. It says that for all possible inputs, the lower bound cannot be beaten. ∀ inputs is not the same as ∃ a worst case input.

Quicksort requires n² comparisons in the worst case; would we then say that quicksort is Ω(n²)?

It's true in the worst case, but it doesn't seem right to me. I don't like putting quantification monikers on order statistics that have lower and upper bounds built into them.

To put it another way, I can use Ω(), Θ(), and O() to characterize heap and bubble sort:

• Heap sort: Θ(nlogn)
• Bubble sort: Ω(n) and O(n²)

Those statements make sense as complexity theory lower (best case) and upper (worst case) bounds. And I don't have to add "best" or "worst" monikers.

If you want to be precise, you do. Heap sort is also Ω(n) and O(n²) because Θ(nlogn) is within those bounds. A precise statement would be that bubble sort is Θ(n²) in the worst case and Θ(n) in the best case. QVVERTYVS (hm?) 08:23, 1 December 2015 (UTC)

In that context, a claim that comparison sorts are Ω(nlogn) is confusing.

I don't see the same confusion with a statement that a comparison sort cannot be better than O(nlogn).

Perhaps the best way out is to avoid order notation and just say comparison sorts require at least nlogn comparisons for some inputs.

Glrx (talk) 23:25, 30 November 2015 (UTC)

That would be a good way of stating the claim, but it's still a classical theorem that I think should be stated as precisely as CLRS state it as well. QVVERTYVS (hm?) 10:08, 1 December 2015 (UTC)

Just a little comment about "at least nlogn comparisons" suggestion. This just doesn't work, because actually it is "at least Cnlogn comparisons" where C is unknown constant. So to say number of operations is proportional to nlogn in worst case scenario (rather than bounded by this exact number), which basically is the meaning on O(nlogn) notation. Trimutius (talk) 14:57, 3 December 2015 (UTC)

• If the lower bound of a comparison sort is ${\displaystyle n\log n}$ comparisons, but the article says ${\displaystyle O(n\log n)}$, then one could, for example, infer that a comparison sort that only requires ${\displaystyle 2n}$ comparisons exists, because ${\displaystyle 2n\leq 2(n\log n){\text{ for all }}n\geq 2}$ (see doi:10.1145/1008328.1008329). ${\displaystyle \Omega }$ notation would be appropriate; such an algorithm would not pass because ${\displaystyle (\exists k:2n\leq c(n\log n){\text{ for all }}n\geq k)}$, no matter how close c is to 0 (also see same page).
• The definitions of big O and Ω notations in Knuth's paper is as follows. Let f and g be functions that map to the real numbers:

-Esquivalience ^t 22:29, 16 February 2016 (UTC)

Well we should just think about what is important for sorts. Best cases of algorithms actually refer to Ω(f(n)), while worst cases refer to O(f(n)), and average case refers to some heuristics, which were made based on all possible inputs. But what is important for the algorithm is for it to be as fast as possible in worst possible case, so O(f(n)) is the only one in practical use for computer algorithms. And even though in tables we can mention that best cases are Ω(f(n)), this information is redundant and not relevant to the subject of the article. Trimutius (talk) 20:47, 17 February 2016 (UTC)

The theorem does not state "the lower bound of a comparison sort is ${\displaystyle n\log n}$ comparisons".

We are interested in the order statistics of sorting algorithms.

The notation has an shorthand connotation just like graph theory algorithms.

Let n be an input sequence of n elements; f(n) is the number of comparisons an algorithm needs to sort n. Shorthand is just f(n), but realize that the shorthand f(n) is not single valued.

Given a particular algorithm, the meaning of O() and Ω() are clear. The first is an upper bound on the comparisons and second is a lower bound on the comparisons. There is no input sequence that will take more than O() comparisons and no input sequence that will take fewer than &Omega().

The theorem states that for some input sequences (not necessarily all input sequences), a comparison sort will require some multiple of n log n comparisons.

That means a comparison sorting algorithm cannot be better than O(n log n).

If somebody claims to have an O(n) comparison sort, then we know they are wrong (or there's a mistake in the theorem).

The theorem does NOT mean that all comparison sorts must be at least Ω(n log n).

We know that the lowly bubble sort is Ω(n) because it will finish in n comparisons for sorted input sequences.

Claiming a sort is Ω(n) does not violate the theorem.

When another quantification ("in the worst case") is placed outside of the notation, it walks outside of the order statistic notation and butchers an interior quantifier.

As it turns out, the order notation is inadequate for what you want to say here. It also adds confusion rather than clarifies.

Glrx (talk) 02:47, 18 February 2016 (UTC)

I'm not really sure what the talk is about? It is pretty obvious that in all referenced literature they use Big O Notation for a particular reason. Because Ω just isn't really important. In all cases where "upper bound" (or "worst case") is used Big O Notation should be used (and only there), though looking at the current state of article this notation is used for average cases for some reason in many cases.

Phrases like "average time complexity of O(n log n)" just don't make sense, and there are at least couple of places where it states that. I'm against using Ω though, because that one isn't related to. We need some kind of alternative. For example just simply saying with words rather than notation: "average time complexity proportional to nlogn". Because that what people are basically trying to say.

Trimutius (talk) 22:26, 19 February 2016 (UTC)

I also agree that it would be best to state the theorem without using asymptotic notation; even TAOCP tends to avoid it:

The best worst case. The first problem that arises naturally is to find comparison trees that minimize the maximum number of comparisons made. (Later we shall consider the average number of comparisons.) Let S(n) be the minimum number of comparisons that will suffice to sort n elements. If all the internal nodes of a comparison tree are at levels < k, it is obvious that there can be at most 2k external nodes in the tree. Hence, letting k = S(n), we have ${\displaystyle S(n)\geq \lceil \log n\rceil }$. Stirling's approximation tells us that ${\displaystyle \lceil \log n!\rceil =n\log n-n/\ln 2-{\frac {1}{2}}\log n+O(1)}$, hence roughly ${\displaystyle n\log n}$ comparisons are needed. – TAOCP § 5.3.1 (Sorting and Searching)

A possible replacement is (ref is TAOCP chapter 5):

The number of comparisons required by a comparison sorting algorithm is roughly n log n comparisons in the worst case (some algorithms require proportionately n log n comparisons);^[1] in better cases, it is possible to perform comparison sorting in at most a multiple of n comparisons.^[2]

-Esquivalience ^t 02:05, 6 March 2016 (UTC)

• Knuth, Donald (1998). The Art of Computer Programming, Volume 3: Sorting and Searching (2nd ed.). Addison-Wesley Professional. {{cite book}}: Invalid |ref=harv (help)

Hello @Glrx:

I've corrected again O with Ω. Reading what has been written on this talk page, I think clarification is needed.

First, I hope we all agree that "A has a fundamental requirement of B" has the same meaning than "A requires B" (unless you want to do some nasty knowledge obfuscation).

Second, the sentences "Comparison sorting algorithms have a fundamental requirement of Ω(n log n) comparisons" or "Comparison sorting algorithms have a fundamental requirement of O(n log n) comparisons" are ambiguous since it doesn't say for which complexity measure. Let us denote X a symbol in {O, Ω}. Unambiguous sentences would be "Comparison sorting algorithms require X(n log n) comparisons for worst case complexity." or "Comparison sorting algorithms require X(n log n) comparisons for best case complexity." or "Comparison sorting algorithms require X(n log n) comparisons for average complexity.", etc. (Average complexity is just the expected complexity for the uniform distribution over all instances of size n. You can have "expected complexity" for other probability distributions.) However, in complexity theory, when the complexity measure is not given explicitly, it is assumed most of the time that it is the worst case complexity.

Third, the choice of the complexity measure (worst case, best case, average, etc.) is independent of the choice of the asymptotic notation ; you can have theorems with O and worst case complexity, with Ω and worst case complexity, with O and best case complexity, with Ω and best case complexity, with O and average complexity, with Ω and average complexity, etc. Please don't assume that worst case complexity is some kind of negation and that Ω is also some kind of negation, like when you say "dont worst-worst the notation" ; it isn't double negation that cancels out or anything similar.

Fourth, if you want to upper bound worst case complexity, you have to prove that all instances are below the bound. If you want to lower bound worst case complexity, you just have to prove that some instance is above the bound. It's pure logic.

Fifth, Trimutius said "I'm not really sure what the talk is about? It is pretty obvious that in all referenced literature they use Big O Notation for a particular reason. Because Ω just isn't really important.". It is true that O is much more frequently encountered than Ω but it isn't "Because Ω just isn't really important.". The fundamental reason for that is that most of the scientific articles present a result on the complexity of a problem ; hence to give an upper bound on the complexity of a problem, it is sufficient to find SOME algorithm for the problem and upper bound the complexity of this algorithm. But if you want to show that the complexity of the problem is lower bounded, you have to prove that ALL possible algorithms for this problem have this lower bound. This is a difference between "there exists one algorithm" and "for all algorithms" that makes it much more harder in general to prove lower bounds for complexity of problems. The effort to lower bound the complexity of the algorithm is usually not done, since they cannot conclude anything with it for the problem, which is the ultimate goal, and also since most of the time the only easy-to-prove lower bound an algorithm has is the trivial lower bound of Ω(n) (the algorithm must read the input). It is expected by most computer scientist that P doesn't equal NP but that is extremely hard to prove because it implies proving a superpolynomial lower bound for some NP problem and thus having to deal with all possible algorithms for this problem. The lower bound for "Comparison sorting algorithms" is really an exception because it simply uses decision trees to be proved. No not-trivial lower bound is known for ALL sorting algorithms. In general, O results are much more easier to prove than Ω results.

Sixth, so now consider the truth value of the four sentences: S1 = "Comparison sorting algorithms require O(n log n) comparisons for worst case complexity.", S2 = "Comparison sorting algorithms require O(n log n) comparisons for best case complexity.", S3 = "Comparison sorting algorithms require Ω(n log n) comparisons for worst case complexity." or S4 = "Comparison sorting algorithms require Ω(n log n) comparisons for best case complexity.". We can translate the mathematical asymptotic notation as follows: S1 = "ALL comparison sorting algorithms require, asymptotically, up to a constant factor, at most n log n comparisons for worst case complexity.", S2 = "ALL comparison sorting algorithms require, asymptotically, up to a constant factor, at most n log n comparisons for best case complexity.", S3 = "ALL comparison sorting algorithms require, asymptotically, up to a constant factor, at least n log n comparisons for worst case complexity." or S4 = "ALL comparison sorting algorithms require, asymptotically, up to a constant factor, at least n log n comparisons for best case complexity.". S1 and S2 are false since you can design poorly some very bad comparison sorting algorithm that will repeat an arbitrary high number of times, say nⁿ, the comparison between the first and second element before proceeding to do a merge sort for example and ultimately solving the problem of sorting. With this poor algorithm the best and worst case will not be too far apart compared to the order of magnitude of their values, and way above n log(n). On the other hand, S3 is true, that's the classical result using decision trees. S4 is false since some comparison sorting algorithm may use only n-1 comparisons on already sorted input which would be the best case. Hence the only correct sentence is "Comparison sorting algorithms require Ω(n log n) comparisons for worst case complexity.". I'll let you check by yourself that "Comparison sorting algorithms require O(n log n) comparisons for whatever complexity." is also false (you can always make a poor algorithm).

I hope I helped at least someone on this topic. Ask questions if it wasn't clear but be aware that I'm not always connected to Wikipedia so the answer may take some time. Best regards, SectionFinale (talk) 15:56, 17 December 2017 (UTC)

The "Twin Sort Technique" (https://arxiv.org/abs/1710.07992) is the latest core computer sorting algorithm and got published recently, and I am the main author of it. Can this be covered and added to your portal (https://en.wikipedia.org/wiki/Sorting_algorithm)? Millions of students, researchers and engineers get benefited out of this addition.

VeereshDevireddy (talk) 15:10, 16 August 2018 (UTC)

The answer is "definitely not" until it is widely cited in professional literature. After looking at your paper, I predict that time will never come. McKay (talk) 07:30, 17 August 2018 (UTC)

I came looking for assistance in manually sorting tens of thousands of random Election Ballots into a hundred geographic (Precinct) districts. Similarly the Postal Services machine-sort millions of pieces of mail into millions of buckets (zipcodes, routes and addresses). Carrier personnel manually direct-sort their mail into an array of "pigeon-holes" before delivery distribution.

Unfortunately all emphasis here is towards electronic Data-processing. I've got to give these lots of thought to determine applicability to physical-sorts, using physical motions, requiring real-time, and limited buckets within reach or operator constraints. Does EDP sort-theory apply, or have lessons for large physical sorts?

Are info or comments about best physical-sort algorithms appropriate here? What differences apply due to human or mechanical vs electronic/cyber media and speeds? HalFonts (talk) 07:20, 19 November 2010 (UTC)

It is usual to measure comparison sorting algorithms based on the number of comparisons, and assume that the number of element moves (or copies) is proportional. As a physical sort problem, consider sorting a deck of playing cards, commonly by insertion sort. Unlike for EDP, a whole group of already sorted cards moves up or down as one operation. I did once, just to see that I could do it, sort a deck of cards with quicksort. Some EDP sort algorithms easily adapt as physical sort algorithms, and others don't. Reminds me, that radix sort was commonly used to sort decks of computer cards in the early EDP days. There were machines built to do this combination of electronic and physical sorting. Gah4 (talk) 13:44, 4 September 2019 (UTC)

Shell sort is clearly not a variant of bubble sort. Why is it listed under the headline "bubble sort and variants"? Dp99 (talk) 09:34, 6 June 2018 (UTC)

It you wanted to know how to make bubblesort into an NlogN sort, shellsort would do it. Gah4 (talk) 20:38, 4 September 2019 (UTC)

It occurs to me that caching effects on modern (or not so modern) processors can greatly affect the speed of some memory access patterns, and that could be significant in some sort algorithm comparisons. Not knowing where else to mention it, though it might be useful in pages for specific sort algorithms, I am starting here. Gah4 (talk) 20:43, 4 September 2019 (UTC)

I agree with "caching effects on modern (or not so modern) processors can greatly affect the speed of some memory access patterns". "(...) and that could be significant in some sort algorithm comparisons", yes. For instance, a sorting algorithm which works on the whole input from the start (such as bubblesort) is less cache-aware than an algorithm such as mergesort which can focus on local solutions, which tend to be contiguous in memory, before going over a larger slice of whole input. BernardoSulzbach (talk) 22:28, 4 September 2019 (UTC)

One example of this is on a processor with an 8 way cache, a 4 way merge sort (without heap, just an if/else tree to determine smallest element), there are 4 cache lines for the 4 runs being merged, and a 5th cache line for the merged output. The end result in my testing is that 4-way merge sort is about 15% faster than 2-way merge sort. Rcgldr (talk) 02:53, 6 September 2019 (UTC)

The dynamic web page in the second paragraph implies (at least to me) a Publicly accessible web page, whose content runs afoul of FERPA.

The second paragraph of the Stability section starts with:

Stability is important for the following reason: say, if the data is sorted first by student name, in some cases, dynamically on the webpage, and now the data is again sorted by which class section they are in.

A webpage containing student name and corresponding class section data would at first glance appear to be "'directory information" but is actually an education record. Therefore if the web page is accessible by others than those with a defined, institutional, education purpose, the web page would be in violation of FERPA.

My feeling is those learning these topics should not be creating things, that, if used with real-life data, would be in violation of the law.

"What is an education record? | Protecting Student Privacy". studentprivacy.ed.gov. US Department of Education. Archived from the original on Christmas 2018. Retrieved 26 February 2020 – via https://studentprivacy.ed.gov/frequently-asked-questions. [...]records include but are not limited to grades, transcripts, class lists, student course schedules, health records (at the K-12 level), student financial information (at the post secondary level), and student discipline files. [...] {{cite web}}: Check date values in: |archive-date= (help); External link in |via= (help)

None of this is relevant to the article. The article is about algorithms for sorting data, not about what should be done with the data. The text also says nothing about publishing the data, so the question of what is legal to publish is entirely irrelevant. McKay (talk) 22:25, 27 February 2020 (UTC)

"FERPA Tutorial - Directory Information|When is Directory Information Not Really Directory Information?". Office of The University Registrar - Penn State. Retrieved 26 February 2020. It is important to also understand the concept of "implicit disclosure." An implicit disclosure may occur when a list consists only of directory information but the list itself by definition reveals non-directory information. For example, a list of names and email addresses of all students who have a particular grade-point average reveals the students' GPAs. Likewise, a class list containing names and email addresses of the students reveals class enrollments. Since neither grade-point average nor class enrollment are directory items, releasing these lists without prior consent of the students constitutes a FERPA violation.{{cite web}}:  CS1 maint: url-status (link)

--Lent (talk) 08:55, 26 February 2020 (UTC)

Try out this sandbox example, which tracks the sorting changes for two different stable sorting examples on the same data:

See User:Lent/sandbox

Thanks --Lent (talk) 11:20, 29 February 2020 (UTC)

I would like to discuss a revert done by an anonymous IP. The reason for the revert was that the expected runtime is given in the average case. This is, however, wrong. The expected runtime is different from the average case. These two names are different concepts: the average case is a description of the input. The input meaning here the list to sort. We assume some distribution of the input and calculate the expectation for the runtime over this distrubtion. This is different for "expected runtime". The 'expected' in 'expected runtime' does not relate to the input, but instead to what we often call 'random bits'. The 'random bits' are not part of the input (this would make the whole concept of probablistic programming ad absurdum). Therefore we can not say that the average-case is identical to the expected runtime. We have infinitely many expected runtimes, especially we have a worst-case expected runtime, a best-case expected runtime and again we also have an average-case expected runtime.

Even worse, saying that the worst-case runtime of bogosort is infinite is at best misleading. That is because there is really no concept in which infinite would be a meaningful runtime for bogosort. I would accept using the phrase 'certainly unbounded', meaning assuming that there is no randomess, the runtime is not bounded by any function depening on the input. Even saying that the runtime is unbounded (without using the word certainly) is misleading as the probability for unbounded runtime is 0 and even the expected runtime is at most n x !n. I would therefore ask to redo my change to fit more with the given source (which uses the same semantics) and with the current research. --PhoenixIra (talk) 17:25, 22 June 2020 (UTC)

Worst case is commonly meant to be the worst possible case, which is unbounded for bogosort. The input in this case would commonly include the worst possible random seed as well. At any rate, we follow the sources, and your addition (and the matching addition at Bogosort) was unsourced. Cite a reputable source and interprets that the worst case behavior as you are and perhaps we can use it. - MrOllie (talk) 17:51, 22 June 2020 (UTC)

I don't agree. Citing CLRS: "The worst-case running time of an algorithm gives us an upper bound on the running time for any input. Knowing it provides a guarantee that the algorithm will never take any longer. We need not make some educated guess about the running time and hope that it never gets much worse." (Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein. Introduction to Algorithms, Third Edition. MIT Press 2009, page 28) and later claryfing: "When analyzing the running time of a randomized algorithm, we take the expectation of the running time over the distribution of values returned by the random number generator. We distinguish these algorithms from those in which the input is random by referring to the running time of a randomized algorithm as an expected running time. In general, we discuss the average-case running time when the probability distribution is over the inputs to the algorithm, and we discuss the expected running time when the algorithm itself makes random choices." (Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein. Introduction to Algorithms, Third Edition. MIT Press 2009, page 117). CLRS also sometimes uses the phrase 'worst-case' complexity when refering to randomized algorithms, when they really mean 'certain worst-case'. Including random bits in the input would also make the runtimes totally absurd: for an infinite runtime, you would need infinite random bits, making an infinite input. This is obviously broken. Again, expectation and worst/average-case are different concepts. Coming to bogosort, we have 'Sorting the slow way: an analysis of perversely awful randomized sorting algorithms': "Let S denote the number of swaps carried out by bogo-sort on a given input x of length n. Then E[S]=(n − 1)n! in the worst and average case." and "Let C denote the number of comparisons carried out by bogo-sort on a given input x of length n. Then E(C) = (e − 1)n! + n − O(1) in the worst-case" (Gruber, H.; Holzer, M.; Ruepp, O., "Sorting the slow way: an analysis of perversely awful randomized sorting algorithms", 4th International Conference on Fun with Algorithms, Castiglioncello, Italy, 2007 (PDF), Lecture Notes in Computer Science, 4475, Springer-Verlag, pp. 183–197, Corollary 6 and 10) and .Again, I am on board with using the phrase "unbounded certainl runtime" and "n x !n expected runtime", however, infinite is wrong and don't mentioning the worst-case expected runtime is bad. --PhoenixIra (talk) 18:11, 22 June 2020 (UTC)

The Gruber et al. conference paper looks good, you've convinced me. Just add a citation to that. - MrOllie (talk) 18:24, 22 June 2020 (UTC)

An introductory sentence says, "For optimum efficiency, the input data should be stored in a data structure which allows random access rather than one that allows only sequential access."

But that is true only when the cost of random access is very small. If the volume of input data is too long to fit in available fast memory (e.g., RAM), then having input data stored in a data structure residing on slow memory (e.g., hard disk, or magnetic tape) then such a data structure can be terrible.

I'm changing the introductory sentence to say, "For optimum efficiency, input data in fast memory should be stored in a data structure which allows random access rather than one that allows only sequential access." DavidForthoffer (talk) 20:41, 4 February 2021 (UTC)

First bullet in 'Classification'

Computational complexity (worst, average and best behavior) in terms of the size of the list (n). For typical serial sorting algorithms, good behavior is O(n log n), with parallel sort in O(log2 n), and bad behavior is O(n2)

Does anyone know what the 'O' for bad behaviour for parallel sorting is?

Darcourse (talk) 10:12, 22 July 2021 (UTC)

Link: https://en.wikipedia.org/wiki/Timsort — Preceding unsigned comment added by 2001:16b8:1e5b:ba00:2c00:cbff:fe64:7ae (talk • contribs)

No, it is there. Look again. - MrOllie (talk) 19:26, 18 August 2021 (UTC)

I was surprised to find no page on wikipedia for comparing online sorting algorithms, and no section in the Online algorithm page. I'm not sure if it deserves its own page, a section in this page with a new comparison table, or maybe a column in an existing comparison table? Privychick (talk) 13:32, 18 March 2022 (UTC)

1 strength of ArrayV is, that the numbers, which are visualized as bars, are always integers, as I have never seen pigeonhole sort failing to sort an array.

There are some wrong time complexities in Sorting algorithm#Others.

Simple pancake sort should be O(n) best and O(n²) average and worst and Bitonic sorter should be O(n log²n), best average and worst, where log²n means (log n)². Well, these time complexities fit well to the results in https://www.youtube.com/watch?v=8MsTNqK3o_w&t=2825s andhttps://www.youtube.com/watch?v=v4Uo0Pi6odo&t=15s. The fastest a sorting algorithm can reach is O(n). In array v oof 2, sb broke ArrayV by running parallel bitonic sort with 16384 numbers, but I think, it was just a freeze bug, like https://www.youtube.com/watch?v=vlLrmCifVRY&t=1646s.

Another strength of ArrayV is how the sorting algorithms are visualized. AceOfSpadesProduc100 himself said in (follow-up video) Threaded pattern-defeating merge sort on ArrayV-v4.0, in Parallel bitonic sort on ArrayV, in Parallel odd-even merge sort on ArrayV and in ArrayV-v4.0's parallel sorting algorithms, that he uses an Intel Core i7-9750H, which has 6 cores and 12 threads. But, the way ArrayV visualizes the sorting algorithms lets the parallel sorting algorithms do the fully parallel method. For example, parallel bitonic sort could use flan sort rotations. 94.31.83.138 (talk) 19:43, 23 August 2023 (UTC)

I find it rather ironic that this table does itself not appear to be sorted! The "exchanging" methods are kept together and are ordered alphabetically, but other than that the order seems to be pretty random. I am in favour of sorting this table according to Method and then name, but other options such as by average case complexity and then name also seem fine to me. It may be like a bit of a plug that Timsort has been placed at the top of this table. There seems to be less reason for it to appear in the table compared to some algorithms that are currently omitted.

Secondly, I'd also like to see a best case column added to the table. Then it would make sense to add other algorithms such as Binary Insertion Sort whose best case differs from normal Insertion Sort, but the average and worst cases are the same. It would also make sense to hilight the fact that bubble sort (amoung others) can be implemeneted with an O(n) best case. Several other algorithms such as Bitonic Merge Sort, Bingo Sort, Odd-Even Transposition Sort, Strand Sort, Squeeze Sort, and Order Sort to name a few, could also be added.

Malcolm —Preceding unsigned comment added by 118.92.109.220 (talk) 03:01, 13 June 2010 (UTC)

13 years later. I just sorted the table in a somewhat heuristic order of best to worst for general use. General use in this case means that you are generally concerned with speed or memory used when you have a large number of elements to sort. For small number of elements, unless you do it repetitively and a lot, nobody is really concerned with speed. So they are now ordered, first by best average, then best worst case, then best best case, then memory used, then stability. If your concern is code size or memory used, you can still reorder the list as you wish. Hope this helps. Now ordering the list in this way reveals that there may be some issues. If you compare Comb sort with Library sort for instance, they have identical best and worst limits, but very different averages. Is this really correct? Dhrm77 (talk) 19:05, 22 October 2023 (UTC)

bold = correction

part 2: https://www.youtube.com/watch?v=wqibJMG42Ik

patience sort: O(n) best, O(n log n) average and worst, O(n) memory, stable

tournament sort: O(n log n) best, average and worst, O(n) memory, stable

bitonic sort: O(n log^2 n) best, average and worst, O(1) memory, unstable

odd-even merge sort: O(n log^2 n) best, average and worst, O(1) memory, unstable

pairwise sorting network: O(n log^2 n) best, average and worst, O(1) memory, unstable

stooge sort: O(n^2.71) best average and worst, O(1) memory, unstable

slow sort: O(n^(log n)) best average and worst, O(1) memory, unstable

variants and hybrids: https://www.youtube.com/watch?v=FntVy6lPVyo

cartesian tree sort: O(n log n) best, average and worst, O(n) memory, stable

Stalin sort: O(n) best, average and worst, O(1) memory, stable

sleep sort: O(n) best, O(n + r) average and worst, O(n) memory, stable

miracle sort: O(n) best (on a sorted list), O(inf) average and worst, O(1) memory, stable

power sort: O(n * n!) best, average and worst, O(n * n!) memory, stable

A sorting algorithm can not be faster than O(n).

Stalin sort increases unsorted values to the largest previously read value (https://www.youtube.com/watch?v=hyOlWQ9MLPI). For example, [1, 2, 5, 3, 6, 4, 10] becomes [1, 2, 5, 5, 6, 6, 10].

Sleep sort is a time-based sorting algorithm. The smallest number wakes up first and the largest number wakes up last (https://www.youtube.com/watch?v=ktgxMtWMflU&t=210s). Equal numbers will wake up at the same time, but waking up is swapless.

Miracle sort only makes comparisons and power sort prints all the permutations in auxiliary arrays, so both of them are swapless.

Swaps of non-adjacent numbers are what makes a sorting algorithm unstable (https://www.youtube.com/watch?v=KJuxI1BBLyQ&t=403s).

some examples

cycle sort, bitonic sort, odd-even merge sort, pairwise sorting network, stooge sort and slow sort: Swap non-adjacent numbers. = unstable

insertion sort and binary insertion sort: Swap only adjacent numbers. = stable

patience sort, tournament sort, cartesian tree sort, Stalin sort, sleep sort, miracle sort and power sort: no swaps = stable 94.31.89.138 (talk) 20:28, 28 October 2023 (UTC)

Just wondered if AI sorts should be added:

• https://www.youtube.com/watch?v=n2qCry_o2Fs
• https://www.youtube.com/watch?v=nF81NVBFLcE

GrahamHardy (talk) 16:42, 23 June 2023 (UTC)

By which I guess you mean improved algorithms recently discovered by AIs. If they are novel concepts they ought to be listed, but the videos seem to say they are speedier versions of known approaches. (I'll try to read the articles linked under the first video.) —Tamfang (talk) 23:45, 18 July 2023 (UTC)

The DeepMind AI sorting algorithm targets sorting 3 to 5 elements and in the case of 5 elements, saves one compare. Not much of a breakthrough. Rcgldr (talk) 07:38, 24 July 2023 (UTC)

That could potentially be significant if it is in a recursive divide-and-conquer algorithm. Bubba73 ^{You talkin' to me?} 05:36, 3 November 2023 (UTC)