Fast sorting by reversal

We present a fast algorithm for sorting on a linear array with a reconfigurable pipelined bus system (LARPBS), one of the recently proposed parallel architectures based on optical buses. Our algorithm sorts N numbers in O(log N log logN) worst-case time using N processors. To our knowledge, the previous best sorting algorithm on this architecture has a running time of O(log2N).KeywordsLinear ArrayRecursive CallSorting AlgorithmMerging AlgorithmDestination ProcessorThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Bayesian network is an important model for reasoning in an uncertain environment. A reliable node rank is required by K2 algorithm to learn Bayesian network structure better. To provide a high-quality node rank tailored for K2 algorithm, we propose a node priority-based sorting algorithm. Given observable data only, our algorithm can be employed to learn a node rank without expert knowledge. Specifically, MCMC algorithm is first utilized to yield some Bayesian network structures that can sufficiently fit the observed data. We then define the priority of each node in these network structures. Node rank is finally obtained through weighted scoring based on the priority. The empirical results show that our sorting algorithm performs significantly better than commonly used methods, e.g., randomly sorting and MCMC algorithm, on an Asia network-learning dataset.

In the past, pseudo code guidelines and intricate blackboard visuals were used to teach methods. This makes visualization technology a useful teaching tool for both students and teachers. In this assignment, we developed an algorithm visualizer. A sorting visualizer and a route finder are also provided. This project intends to provide a platform that could be used to understand better these ideas as well as to illustrate the uses of these various methodologies. As a foundation for learning algorithm design and analysis, Dijkstra's, A*, Deep First Search, Broadness First Search, Rapid Sort, Stack Sort, Sorting Algorithm, Bubble Sort, and other fundamental algorithms are commonly used. Google Street view and web searches are only two examples of software that uses these techniques and that we are using on a daily basis. As a consequence, we made an effort to create a tool that makes use of HTML, CSS, Express's, and other tools to graphically depict how these algorithms work. Our objective is to simplify the algorithm such that basic computer science students may comprehend it via a sequence of graphical stages.

Sorting genomes by generalized translocations

In computational biology, genome rearrangements is a field in which we investigate the combinatorial problem of sorting by transpositions. This problem consists in finding the minimum number of transpositions (mutational event) that transform a chromosome into another. In this work, we implement the 1.5-approximation algorithm proposed by Christie [2] for solving this problem, introducing modifications to reduce its time complexity, and we also propose heuristics to further improve its performance. Comparing our experimental results with the best known results, we had better performance. This work targets to contribute for discovering the complexity of the problem of sorting by transpositions, which remains open.

In this paper, we present an efficient deterministic algorithm for sorting on the LARPBS (Linear Array with a Reconfigurable Pipelined Optical Bus System) model. Our sorting algorithm sorts n general keys in O(logn) time on a LARPBS of size nslogn. The previous best results can sort n items in O(lognloglogn) worst-case time using n processors or sort n items in O((log logn2)worst-case time using n1+ processors. Our algorithm is also scalable to certain extent. When the system size is reduced to nslogn/r for l≤r≤logn, the total computation time is O(rlogn).

Translocation is a prevalent rearrangement event in the evolution of multi-chromosomal species which exchanges ends between two chromosomes. A translocation is reciprocal if none of the exchanged ends is empty; otherwise, non-reciprocal. Given two signed multi-chromosomal genomes A and B , the problem of sorting by translocations is to find a shortest sequence of translocations transforming A into B . Several polynomial algorithms have been presented, all of them only allowing reciprocal translocations. Thus they can only be applied to a pair of genomes having the same set of chromosome ends. Such a restriction can be removed if non-reciprocal translocations are also allowed. In this paper, for the first time, we study the problem of sorting by generalized translocations, which allows both reciprocal translocations and non-reciprocal translocations. We present an exact formula for computing the generalized translocation distance, which leads to a polynomial algorithm for this problem.

Recently, ranking and sorting problems have attracted the attention of researchers in the machine learning community. By ranking, we refer to categorizing examples into one of K categories. On the other hand, sorting refers to coming up with the ordering of the data that agrees with some ground truth preference function. As against standard approaches of treating ranking as a multiclass classification problem, in this paper we argue that ranking/sorting problems can be solved by exploiting the inherent structure present in data. We present efficient formulations that enable the use of standard binary classification algorithms to solve these problems, however the structure is still captured in our formulations. We further show that our approach subsumes the various approaches that were developed in the past. We evaluate our algorithm on both synthetic datasets and for a real world image processing problem. The results obtained demonstrate the superiority of our algorithm over multiclass classification and other similar approaches for ranking/sorting data.KeywordsKernel FunctionSynthetic DataDifference VectorOrdinal RegressionRanking ProblemThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The generalized stack algorithm GSA (L, K), where L denotes the number of branches per state and K the number of extended paths, is a tree or trellis search algorithm combining a metric-first and a breadth-first strategy. The GSA is applied in the equalization of signals disturbed by noise and intersymbol interference (ISI) and in the decoding of convolutional codes. For wide trellises it is not useful to implement a Viterbi algorithm (VA), as the complexity of the VA raises exponentially to the width of the trellis. The GSA follows only C paths (with normally C/spl Gt/K), where C is the capacity of the path memory and the complexity of the GSA increases much less than that of the VA. Instead of it, the GSA requires a sorting device, which is rather expensive. Additionally the number of paths varies during the detection process and the paths have different time indices. Extracting and inserting few paths from a more or less sorted path memory disturbs the order only slightly. So we need only little rearranging effort for the path memory. This paper presents a suitable sorting structure for the GSA for a large path number. The structure exploits the inherent parallelism by a new sorting scheme called extended systolic priority queue (ESPQ). It provides a faster sorting than previous designs.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

We analyze the strong relationship among three combinatorial problems, namely, the problem of sorting a permutation by the minimum number of reversals (MIN-SBR), the problem of finding the maximum ...

We present two fast algorithms for sorting on a linear array with a reconfigurable pipelined bus system (LARPBS), one of the recently proposed parallel architectures based on optical buses. In our first algorithm, we sort N numbers in O(log N log log N) worst-case time using N processors. In our second algorithm, we sort N numbers in O((log log N)/sup 2/) worst-case time using N/sup 1+/spl epsi// processors, for any fixed /spl epsi/ such that 0 < /spl epsi/ < 1. Our algorithms are based on a novel deterministic sampling scheme for merging two sorted arrays of length N each in O(log log N) time on an LARPBS with N processors. To our knowledge, the previous best sorting algorithm on this architecture has a running time of O((log N)/sup 2/) using N processors.

BackgroundOne way to estimate the evolutionary distance between two given genomes is to determine the minimum number of large-scale mutations, or genome rearrangements, that are necessary to transform one into the other. In this context, genomes can be represented as ordered sequences of genes, each gene being represented by a signed integer. If no gene is repeated, genomes are thus modeled as signed permutations of the form pi =(pi _1 pi _2 ldots pi _n), and in that case we can consider without loss of generality that one of them is the identity permutation iota _n =(1 2 ldots n), and that we just need to sort the other (i.e., transform it into iota _n). The most studied genome rearrangement events are reversals, where a segment of the genome is reversed and reincorporated at the same location; and transpositions, where two consecutive segments are exchanged. Many variants, e.g., combining different types of (possibly constrained) rearrangements, have been proposed in the literature. One of them considers that the number of genes involved, in a reversal or a transposition, is never greater than two, which is known as the problem of sorting by super short operations (or SSOs).Results and conclusionsAll problems considering SSOs in permutations have been shown to be in mathsf {P}, except for one, namely sorting signed circular permutations by super short reversals and super short transpositions. Here we fill this gap by introducing a new graph structure called cyclic permutation graph and providing a series of intermediate results, which allows us to design a polynomial algorithm for sorting signed circular permutations by super short reversals and super short transpositions.

Some ant species are known to gather and sort corpses in an auto-organized way. In this contribution, we propose a new cellular ant colony algorithm for sorting and clustering. This algorithm mimics the behavior of real ants. The cellular automata nature of our algorithm implies a straightforward parallelization. The rule consists of a pick-up, a deposition and a diffusion. Our probabilistic pick-up rule is based on some spatial neighborhood information. We observe that probabilistic pick-up yields compact clusters and also speeds up the clustering process. In the long run, a single cluster emerges. Moreover, in the presence of several corpse species, our algorithm sorts the corpses into distinct clusters. Thus our model reproduces realistic results, but however we do not observe any collective effect.KeywordsCellular AutomatonCluster ProcessSingle ClusterAlgorithm SortDeterministic CaseThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Aiming at the main sorting stage of known radar signals in the radar signal sorting system, using supervised learning algorithms in machine learning to replace the traditional sorting algorithms which based on pulse repetition interval. The experimental results show that the supervised learning algorithms can successfully sort overlapping multi-type radar pulse signals, and the sorting accuracy of some algorithms exceeded 95%. It is feasible to apply the supervised learning algorithm to the main sorting stage of known radar signals.

The so-called learned sorting, which was first proposed by Google, achieves data sorting by predicting the placement positions of unsorted data elements in a sorted sequence based on machine learning models. Learned sorting pioneers a new generation of sorting algorithms and shows a great potential because of a theoretical time complexity ON and easy access to hardware-driven accelerating approaches. However, learned sorting has two problems: controlling the monotonicity and boundedness of the predicted placement positions and dealing with placement conflicts of repetitive elements. In this paper, a new learned sorting algorithm named LS is proposed. We integrate a back propagation neural network with the technique of look-up-table in LS to guarantee the monotonicity and boundedness of the predicted placement positions. We design a data structure called the self-regulating index in LS to tentatively store and duly update placement positions for eliminating potential placement conflicts. Results of three controlled experiments demonstrate that LS can effectively control the monotonicity and boundedness, achieve a better time consumption than quick sort and Google’s learned sorting, and present an excellent stability when the data size or the number of repetitive elements increases.