数据结构

来源：互联网发布：淘宝联盟怎么样提现编辑：程序博客网时间：2024/04/28 09:33

http://student.zjzk.cn/course_ware/data_structure/web/paixu/paixu8.3.2.2.htm

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

Comparison sortsNameBestAverageWorstMemoryStableMethodOther notesQuicksort

n \log n

n \log n

n^2

\log n

on average, worst case is

n

; Sedgewick variation is

\log n

worst casetypical in-place sort is not stable; stable versions existPartitioningQuicksort is usually done in place withO(log n) stack space.^{[citation needed]} Most implementations are unstable, as stable in-place partitioning is more complex. Naïvevariants use an O(n) space array to store the partition.^{[citation needed]} Quicksort variant using three-way (fat) partitioning takes O(n) comparisons when sorting an array of equal keys.Merge sort

n \log n

n \log n

n \log n

n

worst caseYesMergingHighly parallelizable (up to O(log n) using the Three Hungarian's Algorithm^{[clarification needed]} or, more practically, Cole's parallel merge sort) for processing large amounts of data.In-place merge sort——

n \log^2 n

1

YesMergingCan be implemented as a stable sort based on stable in-place merging.^[2]Heapsort

n \log n

n \log n

n \log n

1

NoSelection Insertion sort

n

n^2

n^2

1

YesInsertionO(n + d),^{[clarification needed]} where d is the number of inversions.Introsort

n \log n

n \log n

n \log n

\log n

NoPartitioning & SelectionUsed in several STL implementations.Selection sort

n^2

n^2

n^2

1

NoSelectionStable with O(n) extra space, for example using lists.^[3]Timsort

n

n \log n

n \log n

n

YesInsertion & MergingMakes n comparisons when the data is already sorted or reverse sorted.Shell sort

n

n \log^2 n

n^{3/2}

Depends on gap sequence;
best known is

n \log^2 n

1

NoInsertionSmall code size, no use of call stack, reasonably fast, useful where memory is at a premium such as embedded and older mainframe applications.Bubble sort

n

n^2

n^2

1

YesExchangingTiny code size.Binary tree sort

n

n \log n

n \log n (balanced)

n

YesInsertionWhen using a self-balancing binary search tree.Cycle sort—

n^2

n^2

1

NoInsertionIn-place with theoretically optimal number of writes.Library sort—

n \log n

n^2

n

YesInsertion Patience sorting——

n \log n

n

NoInsertion & SelectionFinds all the longest increasing subsequences in O(n log n).Smoothsort

n

n \log n

n \log n

1

NoSelectionAn adaptive sort:

n

comparisons when the data is already sorted, and 0 swaps.Strand sort

n

n^2

n^2

n

YesSelection Tournament sort—

n \log n

n \log n

n

^[4] ?Selection Cocktail sort

n

n^2

n^2

1

YesExchanging Comb sort

n

n \log n

n^2

1

NoExchangingSmall code size.Gnome sort

n

n^2

n^2

1

YesExchangingTiny code size.UnShuffle Sort^[5]

kN

kN

kN

In place for linked lists. N*sizeof(link) for array.Can be made stable by appending the input order to the key.Distribution and MergeNo exchanges are performed. Performance is independent of data size. The constant 'k' is proportional to the entropy in the input. K = 1 for ordered or ordered by reversed input so runtime is equivalent to checking the order O(N).Franceschini's method^[6]—

n \log n

n \log n

1

Yes? Block sort

n

n \log n

n \log n

1

YesInsertion & MergingCombine a block-based O(n) in-place merge algorithm^[7] with a bottom-up merge sort.

The following table describes integer sorting algorithms and other sorting algorithms that are not comparison sorts. As such, they are not limited by a $\Omega(n \log n)$ lower bound. Complexities below assume n items to be sorted, with keys of size k, digit size d, and r the range of numbers to be sorted. Many of them are based on the assumption that the key size is large enough that all entries have unique key values, and hence that n << 2^k, where << means "much less than."

Non-comparison sortsNameBestAverageWorstMemoryStablen << 2^kNotesPigeonhole sort—

n + 2^k

n + 2^k

2^k

YesYes Bucket sort (uniform keys)—

n+k

n^2 \cdot k

n \cdot k

YesNoAssumes uniform distribution of elements from the domain in the array.^[8]Bucket sort (integer keys)—

n+r

n+r

n+r

YesYesIf r is O(n), then Average is O(n).^[9]Counting sort—

n+r

n+r

n+r

YesYesIf r is O(n), then Average is O(n).^[8]LSD Radix Sort—

n \cdot \frac{k}{d}

n \cdot \frac{k}{d}

n

YesNo^[8]^[9]MSD Radix Sort—

n \cdot \frac{k}{d}

n \cdot \frac{k}{d}

n + \frac{k}{d} \cdot 2^d

YesNoStable version uses an external array of size n to hold all of the bins.MSD Radix Sort (in-place)—

n \cdot \frac{k}{d}

n \cdot \frac{k}{d}

\frac{k}{d} \cdot 2^d

NoNo

\frac{k}{d}

recursion levels, 2^d for count array.Spreadsort—

n \cdot \frac{k}{d}

n \cdot \left( {\frac{k}{s} + d} \right)

\frac{k}{d} \cdot 2^d

NoNoAsymptotics are based on the assumption that n << 2^k, but the algorithm does not require this.

The following table describes some sorting algorithms that are impractical for real-life use due to extremely poor performance or specialized hardware requirements.

NameBestAverageWorstMemoryStableComparisonOther notesBead sort—N/AN/A—N/ANoRequires specialized hardware.Simple pancake sort—

n

n

\log n

NoYesCount is number of flips.Spaghetti (Poll) sort

n

n

n

n^2

YesPollingThis a linear-time, analog algorithm for sorting a sequence of items, requiring O(n) stack space, and the sort is stable. This requires n parallel processors. See Spaghetti sort#Analysis.Sorting networks

\log n

\log n

\log n

n \log n

Varies (stable sorting networks require more comparisons)YesOrder of comparisons are set in advance based on a fixed network size. Impractical for more than 32 items.

Theoretical computer scientists have detailed other sorting algorithms that provide better than O(n log n) time complexity assuming additional constraints, including:

Han's algorithm, a deterministic algorithm for sorting keys from a domain of finite size, taking O(n log log n) time and O(n) space.^[10]
Thorup's algorithm, a randomized algorithm for sorting keys from a domain of finite size, taking O(n log log n) time and O(n) space.^[11]
A randomized integer sorting algorithm taking $O\bigl(n \sqrt{\log \log n}\bigr)$ expected time and O(n) space.^[12]

参考

对数函数 http://baike.baidu.com/view/331649.htm

算法时间复杂度计算 http://univasity.iteye.com/blog/1164707

各种算法介绍 http://en.wikipedia.org/wiki/Sorting_algorithm

快速排序java实现 http://www.vogella.com/tutorials/JavaAlgorithmsQuicksort/article.html

0 0