如何对主要排序的数组进行排序

Question

i have an array like this:
1,2,3,5,6,4 it is 99% sorted and has 40K elements.
i can put them in an array, list, linked list, ...
but i don`t know the fastest way to sort them!

Answer 1

以下站点对常见的排序算法进行了比较 - 当集合几乎排序时，似乎插入排序获胜。

Answer 2

"They laughed when I sat down at the keyboard and coded a bubblesort..."

But seriously: Bubblesort is close but not quite. Bubblesort repeatedly moves in one direction, so if there's a low-key value near the top end of the array it and the comparison site "bubbles" upward all the time, it takes many iterations of the main loop for the data item to bubble down against the current. That's pretty much worst case behavior, which for Bubblesort is disastrous.

But there's a refinement to BubbleSort, sometimes called Elevator Cocktail Sort, where the bubble moves in alternating directions: One pass up, one pass down, repeat. This permits single elements to move a long distance in a single pass (or actually, 2 passes), and the number of passes is proportional to the number of elements that need moving. For a small number of unsorted elements, this can approach efficiency.

---

I believe that for the general case, the second link in marek's answer will be faster. The advantage of Bubble/ Elevator Cocktail sort is that it's so simple, it's virtually foolproof, and not a lot of work.

Answer 3

如果它已经下令这样一个高度，而不是-相当排序元素不是远离自己的正确位置，那么这可能是使少数情况下一个冒泡排序是非常有用的。

Answer 4

谷歌为此提供了很多结果 ，例如，本文概述了如何实现这一目标的各种方法： http ： //home.tiac.net/~cri/2004/ksort.html

Answer 5

Put them in an array. You don't want to mess with a 40k linked-list.

There is a very narrow case for CocktailSort (bubblesort in 2 directions). But that depends on what exactly that 1% unsorted means. If there are a few elements displaced, but close to their target positions it might work.

But InsertionSort or ShellSort are almost always going to win. Even in the cases where CocktailSort would theoretically be better, the difference will be small. So they are the (much) safer bet.

Answer 6

As with most questions of this sort, the answer is "That depends...". Do you care if the sort is stable, ie if elements whose keys are equal retain their original relative ordering after being sorted? Do you just care about raw speed? Is simplicity of implementation important? Does memory consumption matter?

Personally, I will always choose a stable sort algorithm, as I'm willing to sacrifice some raw speed for what I consider to be "reasonable" behavior, and non-stable sorting is too often "unreasonable". So I tend to go with the merge-sort algorithm, which is fast and reasonably simple, but it does use extra memory. Another advantage of merge-sort is that if the data is already sorted its complexity is O(n), so for nearly-sorted data it should be close to O(n).

YMMV.

Answer 7

Is performance critical (as verified by a profiler)? Otherwise, just use your framework/langauge's default sort (probably quicksort). It will perform decently.