Deletion Algorithm Research Articles

Maintaining Longest Paths Incrementally

Modeling and programming tools for neighborhood search often support invariants, i.e., data structures specified declaratively and automatically maintained incrementally under changes. This paper considers invariants for longest paths in directed acyclic graphs, a fundamental abstraction for many applications. It presents bounded incremental algorithms for arc insertion and deletion which run in O(∥δ∥ + |δ| log|δ|) time and O(∥δ∥) time respectively, where |δ| and ∥δ∥ are measures of the change in the input and output. The paper also shows how to generalize the algorithm to various classes of multiple insertions/deletions encountered in scheduling applications. Preliminary experimental results show that the algorithms behave well in practice.

Eliminating Duplicates under Interval and Fuzzy Uncertainty: An Asymptotically Optimal Algorithm and Its Geospatial Applications

Geospatial databases generally consist of measurements related to points (or pixels in the case of raster data), lines, and polygons. In recent years, the size and complexity of these databases have increased significantly and they often contain duplicate records, i.e., two or more close records representing the same measurement result. In this paper, we address the problem of detecting duplicates in a database consisting of point measurements. As a test case, we use a database of measurements of anomalies in the Earth's gravity field that we have compiled. In this paper, we show that a natural duplicate deletion algorithm requires (in the worst case) quadratic time, and we propose a new asymptotically optimal O(n⋅ log (n)) algorithm. These algorithms have been successfully applied to gravity databases. We believe that they will prove to be useful when dealing with many other types of point data.

Emerging behavior as binary search trees are symmetrically updated

When repeated updates are made to a binary search tree, the expected search cost tends to improve, as observed by Knott. For the case in which the updates use an asymmetric deletion algorithm, the Knott effect is swamped by the behavior discovered by Eppinger. The Knott effect applies also to updates using symmetric deletion algorithms, and it remains unexplained, along with several other trends in the tree distribution. It is believed that updates using symmetric deletion do not cause search cost to deteriorate, but the evidence is all experimental. The contribution of this paper is to model separately several different trends which may contribute to or detract from the Knott effect, including a previously unreported centripetal tendency.

An Incremental Algorithm for the Maximum Flow Problem

An incremental algorithm may yield an enormous computational time saving to solve a network flow problem. It updates the solution to an instance of a problem for a unit change in the input. In this paper we have proposed an efficient incremental implementation of maximum flow problem after inserting an edge in the network G. The algorithm has the time complexity of O((Δn)2m), where Δn is the number of affected vertices and m is the number of edges in the network. We have also discussed the incremental algorithm for deletion of an edge in the network G.

Performance Evaluation of Lazy Deletion Methods in R-trees

Motivated by the way R-trees are implemented in commercial databases systems, in this paper we examine several deletion techniques for R-trees. In particular, in commercial systems R-tree entries are mapped onto relational tables, which implement their own concurrency protocols on top of existing table-level concurrency mechanisms. In analogy, the actual industrial implementations of B-trees do not apply the well-known merging procedure from textbooks in case of node underflows, but rather they apply the free-at-empty technique. This way, space is sacrificed for the benefit of faster deletions and less locking operations, whereas the search performance practically remains unaffected. In this context, we examine the efficiency of modifications to the original R-tree deletion algorithm, which relax certain constraints of this algorithm and perform a controlled reorganization procedure according to a specified criterion. We present the modified algorithms and experimental results about the impact of these modifications on the tree quality, the execution time for the deletion operation and the processing time of search queries, considering several parameters. The experimental results indicate that the modified algorithms improve the efficiency of the deletion operation, while they do not affect the quality of the R-tree and its performance with respect to search operations.

Complexity classification of some edge modification problems

In an edge modification problem one has to change the edge set of a given graph as little as possible so as to satisfy a certain property. We prove the NP-hardness of a variety of edge modification problems with respect to some well-studied classes of graphs. These include perfect, chordal, chain, comparability, split and asteroidal triple free. We show that some of these problems become polynomial when the input graph has bounded degree. We also give a general constant factor approximation algorithm for deletion and editing problems on bounded degree graphs with respect to properties that can be characterized by a finite set of forbidden induced subgraphs.

Parallel algorithms for red–black trees

We present parallel algorithms for the following four operations on red–black trees: construction, search, insertion, and deletion. Our parallel algorithm for constructing a red–black tree from a sorted list of n items runs in O(1) time with n processors on the CRCW PRAM and runs in O(loglogn) time with n/loglogn processors on the EREW PRAM. Our construction algorithm does not require the assumptions that previous construction algorithms used. Each of our parallel algorithms for search, insertion, and deletion in red–black trees runs in O(logn+logk) time with k processors on the EREW PRAM, where k is the number of unsorted items to search for, insert, or delete and n is the number of nodes in a red–black tree.

Approximating Clique and Biclique Problems

We present here 2-approximation algorithms for several node deletion and edge deletion biclique problems and for an edge deletion clique problem. The biclique problem is to find a node induced subgraph that is bipartite and complete. The objective is to minimize the total weight of nodes or edges deleted so that the remaining subgraph is bipartite complete. Several variants of the biclique problem are studied here, where the problem is defined on bipartite graph or on general graphs with or without the requirement that each side of the bipartition forms an independent set. The maximum clique problem is formulated as maximizing the number (or weight) of edges in the complete subgraph. A 2-approximation algorithm is given for the minimum edge deletion version of this problem. The approximation algorithms given here are derived as a special case of an approximation technique devised for a class of formulations introduced by Hochbaum. All approximation algorithms described (and the polynomial algorithms for two versions of the node biclique problem) involve calls to a minimum cut algorithm. One conclusion of our analysis of the NP-hard problems here is that all of these problems are MAX SNP-hard and at least as difficult to approximate as the vertex cover problem. Another conclusion is that the problem of finding the minimum node cut-set, the removal of which leaves two cliques in the graph, is NP-hard and 2-approximable.

Network Synthesis through Data-Driven Growth and Decay

An algorithm for addition and deletion (ADDEL) of resources during learning is developed to achieve two goals: (1) to find feed-forward multilayer networks that are as small as possible, (2) to find an appropriate structure for such small networks. These goals are accomplished by operating alternately between an adding phase and a deleting phase while learning the given input-output associations. The adding phase develops a crude structure by filling in resources (connections, units and layers) at a virtual multilayer network with a maximum of L possible layers. The deleting phase then removes any unnecessary connections to obtain a refined structure. The additions and deletions are done based on a sensitivity measure and a corresponding probability rule so that only the synapses which are most effective in reducing the output error are preserved. A generalization error estimated from a validation set is used to control the alternation between the two learning phases and the termination of learning. Simulations, including handwritten digit recognition, demonstrate that the algorithm is effective in finding an appropriate network structure for a small network which can generalize well. The algorithm is used to investigate when the size of a network is important for generalization. © 1997 Elsevier Science Ltd.

Deposition and evaporation ofk-mers: Dynamics of a many-state system

When the dynamics of a system partitions the phase space of configurations into very many disjoint sectors, we are faced with an assignment problem: Given a configuration, how can we tell which sector it belongs to? We study this problem in connection with the dynamics of deposition and evaporation ofk particles at a time, from a lattice substrate. Fork ≥ 3, the system shows complex behaviour: (a) The number of disjoint sectors in phase space grows exponentially with the size. (b) The asymptotic time dependence of the autocorrelation function shows slow decays, with power laws which depend on the sector. Both (a) and (b) are explained in terms of a nonlocal construct known as the irreducible string (IS), formed from a particle configuration by applying a deletion algorithm. The IS provides a label for sectors; the multiplicity of possible IS’s accounts for (a), and let us determine sector numbers and sizes. The elements of the IS are conserved; thus their motion is responsible for the slow modes of the system, and accounts for (b) as well.

Two-dimensional dynamic signature file method using extendible hashing and frame-slicing techniques

The signature file method has been widely advocated as an efficient index scheme to handle applications demanding a large amount of text databases. Moreover, many recent applications in practice require a dynamic information storage structure. For this, in this paper, we propose two-dimensional dynamic signature file (TDSF) methods using multilevel extendible hashing and frame-slicing techniques in order to efficiently handle text and multiattribute data in dynamic environments. Due to the characteristics of the extendible hashing technique, the TDSF is suitable for supporting insertions, deletions, and updates. Based on the frame-slicing technique, we divide a signature into several frames, and store each frame in a separate file so that we may increase the filtering effect of the signature file, leading to a decrease in the amount of retrieval required for searching a query. We also describe the storage structure of the TDSF and outline algorithms for signature insertion, retrieval, and deletion. Finally, we derive analytic performance evaluation models of the TDSF methods, and perform extensive experiments with various frame divisions. We show from performance results that, regardless of the database size, the TDSF methods outperform the Quick Filter method in terms of both retrieval time and dynamic operating measure considering the degree of dynamic environment.

The hB $^\Pi$ -tree: a multi-attribute index supporting concurrency, recovery and node consolidation

We propose a new multi-attribute index. Our approach combines the hB-tree, a multi-attribute index, and the $\Pi$-tree, an abstract index which offers efficient concurrency and recovery methods. We call the resulting method the hB $^\Pi$-tree. We describe several versions of the hB $^\Pi$-tree, each using a different node-splitting and index-term-posting algorithm. We also describe a new node deletion algorithm. We have implemented all the versions of the hB $^\Pi$-tree. Our performance results show that even the version that offers no performance guarantees, actually performs very well in terms of storage utilization, index size (fan-out), exact-match and range searching, under various data types and distributions. We have also shown that our index is fairly insensitive to increases in dimension. Thus, it is suitable for indexing high-dimensional applications. This property and the fact that all our versions of the hB $^\Pi$-tree can use the $\Pi$-tree concurrency and recovery algorithms make the hB $^\Pi$-tree a promising candidate for inclusion in a general-purpose DBMS.

An order searching algorithm of extensible hashing

Extensible hashing schemes provide fast key retrieval for dynamic key sets, but they can not keep order preserved searching. In order to solve this problem, Jonge et al. proposed the binary digital search tree (BDS-tree) that enables order preserved searching by extensible hashing schemes, and the method to change the BDS-tree into a compact bit stream (called the pre-order bit stream) However, searching and updating a key takes a lot of time in large key sets. This paper proposes a new method to preserve the key-order access property and to improve the time cost. The algorithms for retrieval, insertion and deletion of keys using this new method are introduced through examples. This method separates the BDS-tree into smaller trees of a certain depth, and creates the pre-order bit stream for each of the separated trees. The theoretical and experimental results, using 50,000 Japanese nouns, show that the presented method provides faster access than the traditional BDS-tree. Retrieval is 18 times, the insertion is 13 times and the deletion is 4 times faster. There is a small increase in the storage requirement for the separated BDS-tree. However, by nature, the pre-order bit stream is very compact in size, thus making the increase insignificant.

Sudden Emergence of a Giantk-Core in a Random Graph

Thek-core of a graph is the largest subgraph with minimum degree at leastk. For the Erdős–Rényi random graphG(n, m) onnvertives, withmedges, it is known that a giant 2-core grows simultaneously with a giant component, that is, whenmis close ton/2. We show that fork⩾3, with high probability, a giantk-core appears suddenly whenmreachesckn/2; hereck=minλ>0 λ/πk(λ) andπk(λ)=P{Poisson(λ)⩾k−1}. In particular,c3≈3.35. We also demonstrate that, unlike the 2-core, when ak-core appears for the first time it is very likely to be giant, of size ≈pk(λk) n. Hereλkis the minimum point ofλ/πk(λ) andpk(λk)=P{Poisson(λk)⩾k}. Fork=3, for instance, the newborn 3-core contains about 0.27nvertices. Our proofs are based on the probabilistic analysis of an edge deletion algorithm that always find ak-core if the graph has one.

Onk-Dimensional Balanced Binary Trees

An amortized analysis of the insertion and deletion algorithms ofk-dimensional balanced binary trees (kBB-trees) is performed. It is shown that the total rebalancing time for a mixed sequence ofminsertions and deletions in akBB-tree of sizenisO(k(m+n)). Based on 2BB-trees, a self-organizing tree, called aself-organizing balanced binary tree, is defined. It is shown that the average access time for an item stored in the tree is optimal to within a constant factor, while the worst-case access time is logarithmic. The amortized analysis ofkBB-trees leads to the result that the total update time for a mixed sequence ofmaccesses, insertions, and (restricted) deletions in a self-organizing balanced binary tree initially storingndata items isO(m+n)

Routing on longest-matching prefixes

This article describes the dynamic prefix tries, a novel data structure with algorithms for insertion, deletion, and retrieval to build and maintain a dynamic database of binary keys of arbitrary length. These tries extend the concepts of compact digital (Patricia) tries to support the storage of prefixes and to guarantee retrieval times at most linear in the length of the input key irrespective of the trie size, even when searching for longest-matching prefixes. The new design permits very efficient, simple and nonrecursive implementations of small code size and minimal storage requirements. Insert and delete operations have strictly local effects, and their particular sequence is irrelevant for the structure of the resulting trie, thus maintaining at all times the desired storage and computational efficiency. The algorithms have bees successfully employed in experimental communication systems and products for a variety of networking functions such as address resolution, maintenance and verification of access control lists, and high-performance routing tables in operating system kernels.

Space saving generalization of B-trees with [formula omitted] utilization

The paper studies balanced trees with variable length records. It generalizes the concept of B-tree with unfixed key length introduced in [1] and S(1)-tree of [2]. The main property of the new trees, called S( b)-trees, is their local incompressibility. That is, any sequence consisting of b + 1 neighboring nodes of the tree cannot be compressed into a b well formed node. The case of S(2)-trees is studied in detail. For these trees, 2 3 − ε utilization lower bound is proven, where ε is inversely proportional to the tree branching. Logarithmic running time algorithms for search, insertion, and deletion are presented.

Optimizing Jan Jannink's Implementation of B + -tree deletion

In this note we propose optimization strategies for the B + -tree deletion algorithm. The optimizations are focused on even order B + -trees and on the reduction of the number of block accesses.

Parallel algorithms for priority queue operations

This paper presents parallel algorithms for priority queue operations on a p-processor EREWPRAM. The algorithms are based on a new data structure, the Min-path Heap (MH), which is obtained as an extension of the traditional binary-heap organization. Using an MH, it is shown that insertion of a new item or deletion of the smallest item from a priority queue of n elements can be performed in O(log n p + log log n) parallel time, while construction of an MH from a set of n items takes O( n p + log n) time. The given algorithms for insertion and deletion achieve the best possible running time for any number of processors p, with p∈O( log n (log log n) ) , while the MH construction algorithm employs up to Θ( n log n ) processors optimally. The paper ends with a brief discussion of the applicability of MH's to the development of efficient parallel algorithms for some important combinatorial problems.

An approximate max-flow min-cut relation for undirected multicommodity flow, with applications

In this paper, we prove the first approximate max-flow min-cut theorem for undirected multicommodity flow. We show that for a feasible flow to exist in a multicommodity problem, it is sufficient that every cut's capacity exceeds its demand by a factor ofO(logClogD), whereC is the sum of all finite capacities andD is the sum of demands. Moreover, our theorem yields an algorithm for finding a cut that is approximately minimumrelative to the flow that must cross it. We use this result to obtain an approximation algorithm for T. C. Hu's generalization of the multiway-cut problem. This algorithm can in turn be applied to obtain approximation algorithms for minimum deletion of clauses of a 2-CNF≡ formula, via minimization, and other problems. We also generalize the theorem to hypergraph networks; using this generalization, we can handle CNF≡ clauses with an arbitrary number of literals per clause.