Optimum multiway search trees

We present a new linear-time algorithm for constructing multiway search trees with near-optimal search cost whose running time is independent of the size of the node in the tree. With the analysis of our construction method, we provide a new upper bound on the average search cost for multiway search trees that nearly matches the lower bound. In fact, it is tight for infinitely many probability distributions. This problem is well-studied in the literature for the case of binary search trees. Using our new construction method, we are able to provide the tightest upper bound on the average search cost for an optimal binary search tree.

We design an efficient sublinear time parallel construction of optimal binary search trees. The efficiency of the parallel algorithm corresponds to its total work (the product time × processors). Our algorithm works in O(n1−ɛ log n) time with the total work O(n2−2ɛ), for an arbitrarily small constant 0 < e ≤ 1/2. This is optimal within a factor n2ɛ with respect to the best known sequential algorithm given by Knuth, which needs only O(n2) time due to a monotonicity property of optimal binary search trees, see [6]). It is unknown how to explore this property in an efficient NC construction of binary search trees. Here we show that it can be effectively used in sublinear time parallel computation. Our improvement also relies on the use (in independently processed small subcomputations) of the parallelism present in Knuth's algorithm. The best known sublinear time algorithms for the construction of binary search trees (as an instance of a more general problem) have O(n3) work for time larger than n3/4, see [3] and [7]. For time √n these algorithms need n4 work, while our algorithm needs for this time only n3 work, thus improving the known algorithms by a linear factor. Also if time is O(n1−ɛ) and e is very small our improvement is close to O(n). Such improvement is similar to the one implied by the monotonicity property in sequential computations (from n3 sequential time for a more general dynamic programming problem to n2 time for the special case of optimal binary search trees).

The searching denotes a process that aims to find a specific item in the data set. After performing the process of searching, the desired items are likely found or not. This kind of investigations was actually demonstrated by some researchers. For each search algorithm, the previous studies just focused to obtain the search time but did not obtain the number of passed-nodes. Furthermore, the results obtained with regards to the search time were not reported systematically. Hence, this study investigates how fast the desired items were found and how few passed-nodes were obtained when searching desired items by using three search algorithms. These algorithms were linear, binary, and interpolation algorithms. By using search algorithms, one hundred twenty desired items were searched in a collection of active-student data (3946 records in total). The search time needed to find a specific item and the number of passed nodes were recorded. The results showed that the searching process with linear search algorithm required more time and more passed-nodes than binary and interpolation search algorithms. Following this, searching time and the number of passed-nodes for desired items were significantly smaller for binary search than for the interpolation search algorithm. Taken together, the present results suggested that the binary search could be considered as a solid algorithm in searching a specific item in the data set utilized by the current study.

Search is considered to be an important functionality in a computational system. Search techniques are applied in file retrievals and indexing. Though there exists various search techniques, binary search is widely used in many applications due to its advantage over other search techniques namely linear and hash search. Binary search is easy to implement and is used to search for an element in a large search space. The worst case time complexity of binary search is O (log 2 n) where n is the number of elements (search space) in the array. However, in binary search, searching is performed on the entire search space. The complexity of binary search may be further reduced if the search space is reduced. This paper proposes an Ant Colony Optimization based Binary Search (ACOBS) algorithm to find an optimal search space for binary search. ACOBS algorithm categorizes the search space and the key element is searched only in a specific category where the key element can exist thereby reducing the search space. The time complexity of ACOBS algorithm is O (log 2 c) where c is the number of elements in the reduced search space and c < n. The proposal is best suited for real time applications where searching is performed on a large domain.KeywordsAnt colony optimizationBinary searchOptimal search space

We describe algorithms for constructing optimal binary search trees, in which the access cost of a key depends on the k preceding keys, which were reached in the path to it. This problem has applications to searching on secondary memory and robotics. Two kinds of optimal trees are considered, namely optimal worst case trees and weighted average case trees. The time and space complexity of both algorithms are O(n k+2) and O(n k+1), respectively. The algorithms are based on a convenient decomposition and characterizations of sequences of keys, which are paths of special kinds in binary search trees. Finally, using generating functions, the exact number of steps performed by the algorithms has been calculated. The subject will be introduced by a general discussion on the construction of optimal binary search trees.

The construction of a spanning tree is a fundamental task in distributed systems which allows to resolve other tasks (i.e., routing, mutual exclusion, network reset). In this paper, we are interested in the problem of constructing a Breadth First Search (BFS) tree. Stabilization is a versatile technique which ensures that the system recover a correct behavior from an arbitrary global state resulting from transient faults. A fully polynomial algorithm has a round complexity in O(da) and a step complexity in O(nb) where d and n are the diameter and the number of nodes of the network and a and b are constants. We present the first fully polynomial stabilizing algorithm constructing a BFS tree under a distributed daemon. Moreover, as far as we know, it is also the first fully polynomial stabilizing algorithm for spanning tree construction. Its round complexity is in O(d2) and its step complexity is in O(n6). To our knowledge, since in general the diameter of a network is much smaller than the number of nodes (log(n) in average instead of n), this algorithm reaches the best compromise of the literature between the complexities in terms of rounds and in terms of steps.

An efficient IP address lookup algorithm based on a small balanced tree using entry reduction

A strongly connected component (SCC) is a maximal subgraph of a directed graph G in which every pair of nodes are reachable from each other in the SCC. With such a property, a general directed graph can be represented by a directed acyclic graph DAG by contracting an SCC of G to a node in DAG. In many real applications that need graph pattern matching, topological sorting, or reachability query processing, the best way to deal with a general directed graph is to deal with its DAG representation. Therefore, finding all SCCs in a directed graph G is a critical operation. The existing in-memory algorithms based on depth first search (DFS) can find all SCCs in linear time w.r.t. the size of a graph. However, when a graph cannot resident entirely in the main memory, the existing external or semi-external algorithms to find all SCCs have limitation to achieve high I/O efficiency. In this paper, we study new I/O efficient semi-external algorithms to find all SCCs for a massive directed graph G that cannot reside in main memory entirely. To overcome the deficiency of the existing DFS based semi-external algorithm that heavily relies on a total order, we explore a weak order based on which we investigate new algorithms. We propose a new two phase algorithm, namely, tree construction and tree search. In the tree construction phase, a spanning tree of G can be constructed in bounded sequential scans of G. In the tree search phase, it needs to sequentially scan the graph once to find all SCCs. In addition, we propose a new single phase algorithm, which combines the tree construction and tree search phases into a single phase, with three new optimization techniques. They are early acceptance, early rejection, and batch processing. By the single phase algorithm with the new optimization techniques, we can significantly reduce the number of I/Os and CPU cost. We conduct extensive experimental studies using 4 real datasets including a massive real dataset, and several synthetic datasets to confirm the I/O efficiency of our approaches.

A Unified Approach to the Parallel Construction of Search Trees

Dalam ilmu komputer terdapat bermacam – macam algoritma untuk metoda pencarian (searching). Beberapa metoda pencarian yang pernah dipelajari adalah metoda pencarian linier (Linear / Sequential Search), pencarian biner (Binary Search) dan pencarian interpolasi (Interpolation Search). Masing – masing algoritma memiliki prasyarat dan cara serta waktu pelaksanaan yang berbeda. Pemilihan atas metoda pencarian dilakukan berdasarkan keadaan dan keinginan pengguna metoda yang biasanya tergantung pada jumlah data, jenis data dan struktur data yang digunakan. Pencarian (searching) merupakan suatu pekerjaan yang sering dikerjakan dalam kehidupan sehari – hari. Ada kalanya kita mencari sesuatu dengan tujuan hanya untuk mengetahui apakah data tersebut ada dalam sekumpulan data atau tidak, sementara di lain waktu mungkin kita menginginkan posisi dari data yang dicari tersebut. Pada tahap simulasi dan analisa, terdapat prosedur ‘SimulasiCari’, yang berfungsi untuk mensimulasikan tahapan – tahapan pencarian dan menampilkan hasil analisis dan prosedur kerja program dalam bentuk report. Prosedur ‘SimulasiCari’ terdiri atas 3 prosedur utama, yaitu ‘LinearSearch’, ‘BinarySearch’ dan ‘InterpolationSearch’. Prosedur ‘LinearSearch’ berfungsi untuk mensimulasikan tahapan pencarian dengan algoritma pencarian linier dan menampilkan hasil analisis dan prosedur kerja program dalam bentuk report. Prosedur ‘BinarySearch’ berfungsi untuk mensimulasikan tahapan pencarian dengan algoritma pencarian biner dan menampilkan hasil analisis dan prosedur kerja program dalam bentuk report. Prosedur ‘InterpolationSearch’ berfungsi untuk mensimulasikan tahapan pencarian dengan algoritma pencarian interpolasi dan menampilkan hasil analisis dan prosedur kerja program dalam bentuk report. Kata Kunci : Pencarian Linier (Linear / Sequential Search), Pencarian Biner (Binary Search) Dan Pencarian Interpolasi (Interpolation Search)

We present an improved wavelet tree construction algorithm and discuss its applications to a number of rank/select problems for integer keys and strings.Given a string of length n over an alphabet of size σ ≤ n, our method builds the wavelet tree in O(n log σ / [EQUATION]log n) time, improving upon the state-of-the-art algorithm by a factor of [EQUATION]log n. As a consequence, given an array of n integers we can construct in O(n[EQUATION]log n) time a data structure consisting of O(n) machine words and capable of answering rank/select queries for the subranges of the array in O(log n/ log log n) time. This is a log log n-factor improvement in query time compared to Chan and Patrascu (SODA 2010) and a [EQUATION]log n-factor improvement in construction time compared to Brodal et al. (Theor. Comput. Sci. 2011).Next, we switch to stringological context and propose a novel notion of wavelet suffix trees. For a string w of length n, this data structure occupies O(n) words, takes O(n[EQUATION]log n) time to construct, and simultaneously captures the combinatorial structure of substrings of w while enabling efficient top-down traversal and binary search. In particular, with a wavelet suffix tree we are able to answer in O(log|x|) time the following two natural analogues of rank/select queries for suffixes of substrings:1) For substrings x and y of w (given by their endpoints) count the number of suffixes of x that are lexicographically smaller than y;2) For a substring x of w (given by its endpoints) and an integer k, find the k-th lexicographically smallest suffix of x.We further show that wavelet suffix trees allow to compute a run-length-encoded Burrows-Wheeler transform of a substring x of w (again, given by its endpoints) in O(s log |x|) time, where s denotes the length of the resulting run-length encoding. This answers a question by Cormode and Muthukrishnan (SODA 2005), who considered an analogous problem for Lempel-Ziv compression.All our algorithms, except for the construction of wavelet suffix trees, which additionally requires O(n) time in expectation, are deterministic and operate in the word RAM model.

The problem of optimal (or near-optimal) exhaustive search for a moving target is of importance in many civilian and military applications. Search-andrescue in open sea or in sparsely-populated areas and search missions for previously-spotted enemy targets are just a few examples. Yet, few known algorithms exist for solving this problem and none of them combine the optimal allocation of search effort with the actual computation of trajectories that a searcher must (and physically can) follow. We propose a divide-andconquer geometric approach for constructing optimal search paths for arbitrarily-shaped regions of interest. The technique is both generalizable to multiple search agents and extensible in that additional real-life search requirements (maneuverability constraints, additional information about the sensor, etc.) can be incorporated into the existing framework. Another novelty of our approach is the ability to optimally deal with a search platform which, due to design constraints, can only perform detection while moving along straight-line sweeps.

Improving on-line construction of two-dimensional suffix trees for square matrices

In the past ten years, there have been a number of data structures that, given a distribution of planar point location queries, produce a planar point location data structure that is tuned for the provided distribution. These structures all suffer from the requirement that the query distribution be provided in advance. For the problem of point location in a triangulation, a data structure is presented that performs asymptotically as well as these structures, but does not require the distribution to be provided in advance. This result is the 2-d analogue of the jump from the optimum binary search trees of Knuth in 1971 which required that the distribution be provided, to the splay trees of Sleator and Tarjan in 1985 where in the static optimality theorem it was proven that splay trees had the same asymptotic performance of optimum search trees without being provided the probability distribution.

There are two major paradigms for linear-space heuristic search: iterative deepening (IDA*) and recursive best-first search (RBFS). While the node regeneration overhead of IDA* is easily characterized in terms of the heuristic branching factor, the overhead of RBFS depends on how widely the promising nodes are separated in the search tree, and is harder to anticipate. In this paper, we present two simple techniques for improving the performance of RBFS while maintaining its advantages over IDA*. While these techniques work well in practice, they do not provide any theoretical bounds on the amount of regeneration overhead. To this end, we introduce RBFScr, the first method for provably bounding the regeneration overhead of RBFS. We show empirically that this improves its performance in several domains, both for optimal and suboptimal search, and also yields a better linear-space anytime heuristic search. RBFScr is the first linear space best-first search robust enough to solve a variety of domains with varying operator costs.