排序是计算机的一项常见且无处不在的活动。存在大量的排序算法并不奇怪。对于所有的排序算法，排序算法是线性的或O（N lg N）是公认的性能极限。性能上的线性下限源于排序算法使用数据的排序属性。排序算法通过排序属性使用比较来将数据元素从初始排列排列成排序排列。线性O（N）排序算法是存在的，但是使用数据的先验知识来使用数据的特定属性，因此具有更好的性能。线性排序算法是利用数据比较的普适性质进行推广的，但有一个线性性能下限。排序算法中的折衷是通过用于对数据元素进行排序的所选属性来实现性能的通用性。一个通用的，线性排序算法的上下文中的权衡性能的一般性，在第一次考虑似乎是难以置信的。但是，有一个隐含的假设，即只有排序属性是普遍的。但是，正如将要讨论和检查的那样，它不是数据元素的唯一通用属性。二进制排序是一种通用的排序算法，它使用另一个通用属性来线性排序。
英文摘要：
Sorting is a common and ubiquitous activity for computers. It is not surprising that there exist a plethora of sorting algorithms. For all the sorting algorithms, it is an accepted performance limit that sorting algorithms are linearithmic or O(N lg N). The linearithmic lower bound in performance stems from the fact that the sorting algorithms use the ordering property of the data. The sorting algorithm uses comparison by the ordering property to arrange the data elements from an initial permutation into a sorted permutation.
Linear O(N) sorting algorithms exist, but use a priori knowledge of the data to use a specific property of the data and thus have greater performance. In contrast, the linearithmic sorting algorithms are generalized by using a universal property of data-comparison, but have a linearithmic performance lower bound. The trade-off in sorting algorithms is generality for performance by the chosen property used to sort the data elements.
A general-purpose, linear sorting algorithm in the context of the trade-off of performance for generality at first consideration seems implausible. But, there is an implicit assumption that only the ordering property is universal. But, as will be discussed and examined, it is not the only universal property for data elements. The binar sort is a general-purpose sorting algorithm that uses this other universal property to sort linearly.
We present an $O(n\sqrt{\log n})$ time and linear space algorithm for sorting real numbers. This breaks the long time illusion that real numbers have to be sorted by comparison sorting and take $Ω(n\log n)$ time to be sorted.
This notes explains how standard algorithms that construct sorting networks have been formalised and proved correct in the Coq proof assistant using the SSReflect extension.
We present an extremely simple sorting algorithm. It may look like it is obviously wrong, but we prove that it is in fact correct. We compare it with other simple sorting algorithms, and analyse some of its curious properties.
We present one stable mergesort algorithm, called \Adaptive Shivers Sort, that exploits the existence of monotonic runs for sorting efficiently partially sorted data. We also prove that, although this algorithm is simple to implement, its computational cost, in number of comparisons performed, is optimal up to a small additive linear term.
Sorting a set of items is a task that can be useful by itself or as a building block for more complex operations. The more sophisticated and fast sorting algorithms become asymptotically, the less efficient they are for small sets of items due to large constant factor. This thesis aims to determine if there is a faster way to sort base case sizes than using insertion sort. For that we looked at sorting networks and how to implement them efficiently. Because sorting networks need to be implemented explicitly for each input size, providing networks for larger sizes becomess less efficient. That …
Sorting is a foundational problem in computer science that is typically employed on sequences or total orders. More recently, a more general form of sorting on partially ordered sets (or posets), where some pairs of elements are incomparable, has been studied. General poset sorting algorithms have a lower-bound query complexity of $Ω(wn + n \log n)$, where $w$ is the width of the poset. We consider the problem of sorting in trees, a particular case of partial orders, and parametrize the complexity with respect to $d$, the maximum degree of an element in the tree, as $d$ is usually much smaller…
Sorting a set of items is a task that can be useful by itself or as a building block for more complex operations. That is why a lot of effort has been put into finding sorting algorithms that sort large sets as fast as possible. But the more sophisticated and complex the algorithms become, the less efficient they are for small sets of items due to large constant factors. We aim to determine if there is a faster way than insertion sort to sort small sets of items to provide a more efficient base case sorter. We looked at sorting networks, at how they can improve the speed of sorting few element…
Generalized sorting problem, also known as sorting with forbidden comparisons, was first introduced by Huang et al. together with a randomized algorithm which requires $\tilde O(n^{3/2})$ probes. We study this problem with additional predictions for all pairs of allowed comparisons as input. We propose a randomized algorithm which uses $O(n \log n+w)$ probes with high probability and a deterministic algorithm which uses $O(nw)$ probes, where $w$ is the number of mistakes made by prediction.
Motivated by the development of computer theory, the sorting algorithm is emerging in an endless stream. Inspired by decrease and conquer method, we propose a brand new sorting algorithmUltimately Heapsort. The algorithm consists of two parts: building a heap and adjusting a heap. Through the asymptotic analysis and experimental analysis of the algorithm, the time complexity of our algorithm can reach O(nlogn) under any condition. Moreover, its space complexity is only O(1). It can be seen that our algorithm is superior to all previous algorithms.
The \emph{generalized sorting problem} is a restricted version of standard comparison sorting where we wish to sort $n$ elements but only a subset of pairs are allowed to be compared. Formally, there is some known graph $G = (V, E)$ on the $n$ elements $v_1, \dots, v_n$, and the goal is to determine the true order of the elements using as few comparisons as possible, where all comparisons $(v_i, v_j)$ must be edges in $E$. We are promised that if the true ordering is $x_1 < x_2 < \cdots < x_n$ for $\{x_i\}$ an unknown permutation of the vertices $\{v_i\}$, then $(x_i, x_{i+1}) \in E$ for all $…
This dissertation focuses on two fundamental sorting problems: string sorting and suffix sorting. The first part considers parallel string sorting on shared-memory multi-core machines, the second part external memory suffix sorting using the induced sorting principle, and the third part distributed external memory suffix sorting with a new distributed algorithmic big data framework named Thrill.
We introduce a new sorting algorithm that is the combination of ML-enhanced sorting with the In-place Super Scalar Sample Sort (IPS4o). The main contribution of our work is to achieve parallel ML-enhanced sorting, as previous algorithms were limited to sequential implementations. We introduce the In-Place Parallel Learned Sort (IPLS) algorithm and compare it extensively against other sorting approaches. IPLS combines the IPS4o framework with linear models trained using the Fastest Minimum Conflict Degree algorithm to partition data. The experimental results do not crown IPLS as the fastest alg…
University of Science and Technology of China（中国科学技术大学）；Lanzhou University（兰州大学）；State University of New York at Stony Brook（纽约州立大学石溪分校）
We propose an $O(N\cdot M)$ sorting algorithm by Machine Learning method, which shows a huge potential sorting big data. This sorting algorithm can be applied to parallel sorting and is suitable for GPU or TPU acceleration. Furthermore, we discuss the application of this algorithm to sparse hash table.
An In-Place Sorting with O(n log n) Comparisons and O(n) Moves
我们提出的第一个就地算法排序的大小为n的数组，执行，在最坏的情况下，最多O（n log n）的元素比较和O（n）的元素传输。这解决了一个长期存在的公开问题，明确指出，例如，在[J. I. Munro和V. Raman，Sorting with minimum data movement，J. Algorithms，13，374-93，1992]，是否存在同时匹配所有计算资源上的渐近下界的排序算法。
The quest for efficient sorting is ongoing, and we will explore a graph-based stable sorting strategy, in particular employing comparison graphs. We use the topological sort to map the comparison graph to a linear domain, and we can manipulate our graph such that the resulting topological sort is the sorted array. By taking advantage of the many relations between Hamiltonian paths and topological sorts in comparison graphs, we design a Divide-and-Conquer algorithm that runs in the optimal $O(n \log n)$ time. In the process, we construct a new merge process for graphs with relevant invariant pr…
There has been surprisingly little work on algorithms for sorting strings on distributed-memory parallel machines. We develop efficient algorithms for this problem based on the multi-way merging principle. These algorithms inspect only characters that are needed to determine the sorting order. Moreover, communication volume is reduced by also communicating (roughly) only those characters and by communicating repetitions of the same prefixes only once. Experiments on up to 1280 cores reveal that these algorithm are often more than five times faster than previous algorithms.
