Showing papers on "Sorting published in 1985"
TL;DR: Tight upper and lower bounds are proved on the number of processors, information transfer, wire area, and time needed to sort N numbers in a bounded-degree fixed-connection network.
Abstract: In this paper, we prove tight upper and lower bounds on the number of processors, information transfer, wire area, and time needed to sort N numbers in a bounded-degree fixed-connection network. Our most important new results are: 1) the construction of an N-node degree-3 network capable of sorting N numbers in O(log N) word steps; 2) a proof that any network capable of sorting N (7 log N)-bit numbers in T bit steps requires area A where AT2 = ?(N2 log2 N); and 3) the construction of a ``small-constant-factor'' bounded-degree network that sorts N ?(log N)-bit numbers in T = ?(log N) bit steps with A = ?(N2) area.
395 citations
TL;DR: The concept of presortedness and its use in sorting is studied, and a new insertion sort algorithm is shown to be optimal with respect to three natural measures.
Abstract: The concept of presortedness and its use in sorting are studied. Natural ways to measure presortedness are given and some general properties necessary for a measure are proposed. A concept of a sorting algorithm optimal with respect to a measure of presortedness is defined, and examples of such algorithms are given. A new insertion sort algorithm is shown to be optimal with respect to three natural measures. The problem of finding an optimal algorithm for an arbitrary measure is studied, and partial results are proven.
136 citations
TL;DR: Probabilistic parallel algorithms are described to sort n keys and to select the k-smallest element among them to meet the information theoretic lower bounds.
Abstract: Probabilistic parallel algorithms are described to sort n keys and to select the k-smallest element among them. For each problem we construct a probabilistic parallel decision tree. The tree for selection finishes with high probability in constant time and the sorting tree in time $O(\log n)$. The same time bound for sorting can also be achieved by a probabilistic parallel machine consisting of n RAMs, each with small private memory, and a common memory of size $O(n)$. These algorithms meet the information theoretic lower bounds.
124 citations
Patent•
12 Sep 1985
TL;DR: In this article, an item characterizing code on each of a succession of items of different varieties loaded onto a conveyor is compared to item characterizations in the requirements of stored orders to select an order requiring each item and, in dependence on the order that is selected, sorting the articles to order-related locations and/or applying order related labels.
Abstract: An item characterizing code on each of a succession of items of different varieties loaded onto a conveyor is compared to item characterizations in the requirements of a succession of stored orders to select an order requiring each item and, in dependence on the order that is selected, sorting the articles to order-related locations and/or applying order-related labels to the items. Multiple selective printers may be provided for use in succession for successive labels.
76 citations
TL;DR: A parallel algorithm for sorting n data items in O(n) steps is presented and its simple structure and the fact that it needs local communication only make it suitable for an implementation in VLSI technology.
Abstract: A parallel algorithm for sorting n data items in O(n) steps is presented. Its simple structure and the fact that it needs local communication only make it suitable for an implementation in VLSI technology. The algorithm is based on a merge algorithm that merges four subfiles stored in a mesh-connected processor array. This merge algorithm is composed of the perfect shuffle and odd-even-transposition sort. For the VLSI implementation a systolic version of the algorithm is presented. The area and time complexities for a bit-serial and a bit-parallel version of this implementation are analyzed.
72 citations
TL;DR: The recently introduced balanced sorting network has the property that no comparator in the network is critical in the sense that any faulty comparator can be bypassed without disturbing the functionality of the network (just its speed); the novelty of the design is that the robustness is derived from the underlying algorithm.
Abstract: Beginning with the recently introduced balanced sorting network, we propose a shuffle-exchange type layout consisting of a single block with the output recirculated back as input until sorting is achieved. Although this network has essentially the same performance bounds as Batcher's bitonic sort, our design has the property that no comparator in the network is critical in the sense that any faulty comparator can be bypassed without disturbing the functionality of the network (just its speed). The novelty of the design is that the robustness is derived from the underlying algorithm. The network will sort in the presence of many faulty comparators. Moreover, of the (N log N)/2 comparators, only N pairs of comparators are critical. That is, the network fails only when both comparators in a pair fail. Our results enable one to build large sorting networks on a single wafer so that a high percentage of the fabricated wafers can be used; some of the wafers will sort very quickly (the ones with no faulty components), most will sort at somewhat slower than optimal speeds, but only a few will fail to be useful as sorting networks (due to too many badly placed faults).
63 citations
TL;DR: Lower bounds of n2/2 and 3n2/4 messages are proved for a worst case execution of any algorithm to solve the ranking and sorting problems, respectively.
Abstract: We study the problems of sorting and ranking n processors that have initial values (not necessarily distinct) in a distributed system. Sorting means that the initial values have to move around in the network and be assigned to the processors according to their distinct identities, while ranking means that the numbers 1, 2,..., n have to be assigned to the processors according to their initial values; ties between initial values can be broken in any chosen way. Assuming a tree network, and assuming that a message can contain an initial value, an identity, or a rank, we present an algorithm for the ranking problem that uses, in the worst case, at most n2/2+O(n) such messages. The algorithm is then extended to perform sorting, using in the worst case at most 3n2/4+O(n) messages. Both algorithms are using a total of O(n) space. The algorithms are extended to general networks. The expected behavior of these algorithms for three classes of trees is discussed. Assuming that the initial values, identities, and ranks can be compared only within themselves, lower bounds of n2/2 and 3n2/4 messages are proved for a worst case execution of any algorithm to solve the ranking and sorting problems, respectively.
56 citations
Patent•
25 Oct 1985TL;DR: A sheet stacking device and an image forming apparatus were provided with the sheet stack device as mentioned in this paper, which has a sheet sorting function, and in addition, sheet re-feeding function so as to make it possible to produce a duplex copy or superimposed copy.
Abstract: A sheet stacking device and an image forming apparatus provided with the sheet stacking device. The sheet stacking device has a sheet sorting function, and in addition, sheet re-feeding function so as to make it possible to produce a duplex copy or superimposed copy. It is further possible to use the sorter portion as a sheet feeding facility.
54 citations
TL;DR: A generalization of a known class of parallel sorting algorithms is presented, together with a new interconnection to execute them, and it is shown that an algorithm in the class is executable in O(log n) time by a chip occupying O(n2) area.
Abstract: A generalization of a known class of parallel sorting algorithms is presented, together with a new interconnection to execute them. A VLSI implementation is also proposed, and its area-time performance is discussed. It is shown that an algorithm in the class is executable in O(log n) time by a chip occupying O(n2) area. The design is a typical instance of a ``hybrid architecture,'' resulting from the combination of well-known VLSI networks as the orthogonal trees and the cube-connected cycles; it also provably meets the AT2 = ?(n2 log2 n) lower bound for sorters of n words of length (1 + ?) log n (? ≫ 0).
51 citations
[...]
TL;DR: The problem of sorting a file distributed over a number of sites of a communication network is examined, and distributed solution algorithms are presented and their communication complexity analyzed both in the worst and in the average case.
Abstract: The problem of sorting a file distributed over a number of sites of a communication network is examined. Two versions of this problem are investigated; distributed solution algorithms are presented; and their communication complexity analyzed both in the worst and in the average case. The worst case bounds are shown to be sharp, with respect to order of magnitude, for large files.
Patent•
23 Oct 1985
TL;DR: In this article, a method for sorting computer data records in a minimum amount of time is described, where records are sorted according to their keys, typically from the most significant digit, or character to the least significant.
Abstract: A method is disclosed which provides for sorting computer data records in a minimum amount of time. Records are sorted according to their keys, typically from the most significant digit, or character to the least significant. The records are placed in or associated with various bins depending on the character on which the record is presently being sorted. These bins are linked together and appended to a front section when they are completely sorted. A first process in the present invention involves testing for equality between characters in adjacent records, and if equality does exist, not performing numerous otherwise necessary but tedious and time consuming procedures. A second process involves the use of an auxiliary or "bins used" table to identify the bins actually used in the current group of records. This auxiliary table is used to determine which bins to process if only a few bins are used. These two novel processes independently and in combination result in a reliably faster and more efficient sorting procedure than previously known, and may be applied to any type of bin type sorting procedure.
IBM1
TL;DR: A hypothetical Bucket-Sort implementation that uses bubble memory is described and a new software marking technique is introduced that reduces the effective time for an associative search.
Abstract: BucketSort is a new external sorting algorithm for very large files that is a substantial improvement over merge sorting with disks BucketSort requires an associative secondary storage device, which can be realized by large disk drives with logic-per-track capabilities or by magnetic bubble memory (MBM) This paper describes and analyzes a hypothetical Bucket-Sort implementation that uses bubble memory A new software marking technique is introduced that reduces the effective time for an associative search
TL;DR: This work sets up a relationship to a general class of linear and nonlinear fast algorithms such as FFT, FWT, and optimal sorting using a slightly modified Viterbi algorithm of an increased basis.
Abstract: The Viterbi algorithm is an efficient technique to estimate the state sequence of a discrete-time finite-state Markov process in the presence of memoryless noise. This work sets up a relationship to a general class of linear and nonlinear fast algorithms such as FFT, FWT, and optimal sorting. The performance of a Viterbi detector is a function of the minimum distance between signals in the observation space of the estimated Markov process. It is shown that this distance may efficiently be calculated with dynamic programming using a slightly modified Viterbi algorithm of an increased basis.
TL;DR: A new model of computation for VLSI, based on the assumption that time for propagating information is at least linear in the distance, is proposed, which is especially suited for deriving lower bounds and trade-offs.
Abstract: A new model of computation for VLSI, based on the assumption that time for propagating information is at least linear in the distance, is proposed. While accommodating for basic laws of physics, the model is designed to be general and technology independent. Thus, from a complexity viewpoint, it is especially suited for deriving lower bounds and trade-offs. New results for a number of problems, including fan-in, transitive functions, matrix multiplication, and sorting are presented. As regards upper bounds, it must be noted that, because of communication costs, the model clearly favors regular and pipelined architectures (e.g., systolic arrays).
21 Oct 1985
TL;DR: The main result is that sorting n integers with n processors requires Ω(√log n) steps in this strong model, which shows that computing any symmetric polynomial requires exactly log2n steps, for any finite number of processors.
Abstract: We consider PRAM's with arbitrary computational power for individual processors, infinitely large shared memory and "priority" writeconflict resolution. The main result is that sorting n integers with n processors requires Ω(√log n) steps in this strong model. We also show that computing any symmetric polynomial (e.g. the sum or product) of n integers requires exactly log2n steps, for any finite number of processors.
01 Dec 1985
TL;DR: Finite geometries are used to construct explicitly highly expanding graphs with essentially the smallest possible number of edges to improve significantly previous results on a parallel sorting problem, by describing an explicit algorithm to sort elements in time units using &Ogr;(n ) processors.
Abstract: Expanding graphs and superconcentrators are relevant to theoretical computer science in several ways. Here we use finite geometries to construct explicitly highly expanding graphs with essentially the smallest possible number of edges.Our graphs enable us to improve significantly previous results on a parallel sorting problem, by describing an explicit algorithm to sort n elements in k time units using O(nak) processors, where, e.g., a2 = 7/4.Using our graphs we can also construct efficient n-superconcentrators of limited depth. For example, we construct an n superconcentrator of depth 3 with O(n4/3) edges; better than the previous known results.
01 Jan 1985
TL;DR: These algorithms cost only logarithmic time and are the first known that are optimal: the product of their time and processor bounds are bounded by a linear function of the input size.
Abstract: : This document gives new parallel algorithms for integer sorting and undirected graph connectivity problems such as connected components and spanning forest. These algorithms cost only logarithmic time and are the first known that are optimal: the product of their time and processor bounds are bounded by a linear function of the input size. All previous known parallel algorithms for these problems required at least a linear number of processors to achieve logarithmic time bounds, and hence were nonoptimal by at least a logarithmic factor. The author assumes a parallel random access machine (RAM) model which allows both concurrent writes and concurrent reads of global memory. The algorithms are randomized; each processor is allowed an independent random number generator; however our stated resource bounds hold for worst case input with overwhelming likelihood as the input size grows. (Author)
TL;DR: Results of a study of the fundamentals of sorting are presented, with emphasis on understanding sorting and on minimizing the time required to sort with electronic equipment of reasonable cost.
Abstract: This paper presents results of a study of the fundamentals of sorting. Emphasis is placed on understanding sorting and on minimizing the time required to sort with electronic equipment of reasonable cost. Sorting is viewed as a combination of information gathering and item moving activities. Shannon's communication theory measure of information is applied to assess the difficulty of various sorting problems. Bounds on the number of comparisons required to sort are developed, and optimal or near-optimal sorting schemes are described and investigated. Three abstract sorting models based on cyclic, linear, and randomaccess memories are defined. Optimal or near-optimal sorting methods are developed for the models and their parallel-register extensions. A brief review of the origin of the work and some of its hypotheses is also presented.
DOI•
01 Jul 1985
TL;DR: The paper discusses the problem of developing automatic sorting of radar environments, in order to assist, and eventually replace, the ESM equipment operator, and separates the signal sorting problem into two subproblems of describing the radar environment in a pulse-train sorter and monitoring changes in the perceived environment in new-signal detector.
Abstract: As radar signal environments become denser and radar signals become more complex, the task of an ESM operator becomes more difficult In environments where the numbers of radars may be large and the number of pulses transmitted by a radar may be small, the operator becomes the dominating factor in the efficiency of an ESM system The paper discusses the problem of developing automatic sorting of radar environments, in order to assist, and eventually replace, the ESM equipment operator The paper separates the signal sorting problem into two subproblems of describing the radar environment in a pulse-train sorter and monitoring changes in the perceived environment in a new-signal detector Emphasis is placed on the need to use all available pulse parameter measurement data in order to achieve the highest possible confidence in the descriptions of the emitters which the signal sorter provides
[...]
TL;DR: Taking a graph-theoretic view of sorting, generalizations of the problem of serial sorting are motivated, and recent results on parallel sorting, and sorting in rounds, which depend on deep graph- theoretic results are described.
Abstract: We discuss connections between sorting algorithms and graph theory. Taking a graph-theoretic view of sorting, we motivate generalizations of the problem of serial sorting, and describe recent results on parallel sorting, and sorting in rounds, which depend on deep graph-theoretic results.
TL;DR: This paper analyzes how to sort n k-bit numbers in a minimum storage network and derivesSharp bounds are derived, which demonstrate that the minimum storage requirements depend quite strongly on the I/O schedule, and on the sorting model.
Abstract: This paper analyzes how to sort n k-bit numbers in a minimum storage network. The techniques also give new AT2 lower bounds for a VLSI sorting model. The principal results in this paper are as follows. ? Lower bounds are given for the minimum storage (and area) needed to sort n k-bit numbers, and accompanying upper bounds (sorting networks) are presented, which match the lower bounds, up to a constant factor. ? Sharp bounds are derived, which demonstrate that the minimum storage requirements depend quite strongly on the I/O schedule, and on the sorting model. ? AT2 lower bounds are established for a VLSI device that sorts n k-bit numbers where k ≪ log n.
TL;DR: Six more algorithms are presented which are unstable but operate on arrays which achieve the previously unattainable lower bound in partition exchange sorting and are compared to potential contenders in multiset sorting.
Abstract: When sorting a multiset of N elements with n ≪ N distinct values, considerable savings can be obtained from an algorithm which sorts in time O(N log n) rather than O(N log N). In a previous paper, two Quicksort derivatives operating on linked lists were introduced which are stable, i.e., maintain the relative order of equal keys, and which achieve the previously unattainable lower bound in partition exchange sorting. Here, six more algorithms are presented which are unstable but operate on arrays. One of the algorithms is also designed for a speedup on presorted input. The algorithms are analyzed and compared to potential contenders in multiset sorting.
TL;DR: This paper presents parallel algorithms to determine properties of regions,such as area; to perform operations on regions, such as union and intersection; to determine if a point lies inside a region; and to determine whether a given digital curve could be the boundary of a region.
01 Dec 1985
TL;DR: This generalization of sorting is discussed together with related computational problems about how many questions are needed to identify an unknown ordered set which is known to be isomorphic to a given "pattern" ordered set Po.
Abstract: How many questions are needed to identify an unknown ordered set which, however, is known to be isomorphic to a given "pattern" ordered set Po? This generalization of sorting is discussed together with related computational problems.
TL;DR: An adaptation of DPS, which estimates the cumulative distribution function of the input data from a randomly selected sample, was developed and tested, and runs only 2-4 percent slower than DPS in the uniform case, but outperforms DPS by 12-13 percent on exponentially distributed data for sufficiently large files.
Abstract: Distributive Partitioned Sort (DPS) is a fast internal sorting algorithm which rung in O(n) expected time on uniformly distributed data. Unfortunately, the method is biased toward such inputs, and its performance worsens as the data become increasingly nonuniform, such as with highly skewed distributions. An adaptation of DPS, which estimates the cumulative distribution function of the input data from a randomly selected sample, was developed and tested. The method runs only 2-4 percent slower than DPS in the uniform case, but outperforms DPS by 12-13 percent on exponentially distributed data for sufficiently large files.
TL;DR: In this article, the Monte-Carlo method without sorting is developed by using the segmentation between the sufficient upper bound and the sufficient lower bound of the evaluated top event frequencies into meshes and interpolation within the mesh.
TL;DR: (n log n) time is required to sort n integers using comparison, addition, subtraction, multiplication, division, indirect addressing, and mildly restricted truncation.
Abstract: ?(n log n) time is required to sort n integers using comparison, addition, subtraction, multiplication, division, indirect addressing, and mildly restricted truncation.