Improved search-tree algorithms for the cluster edit problem. (c2011)

2011 ◽  
Author(s):  
Ali Kassem Ghrayeb
Keyword(s):  
Search Tree ◽  
Tree Algorithms

scholarly journals An Improved Lock-Free Binary Search Tree

2019 ◽  
Author(s):  
Nicholas Whitlock ◽  
José C. Luís ◽  
Sam Shannon ◽  
Mark Alano ◽  
COP 4520
Keyword(s):  
Search Tree ◽  
Binary Search ◽  
Binary Search Tree ◽  
Performance Loss ◽  
Tree Algorithms ◽  
Tree Data ◽  
Software Engineers ◽  
The Many ◽  
Progression Factor ◽  
Tree Data Structure

We investigated the binary search tree data structure proposed in the publication, Efficient Lock-Free Binary Search Trees by Bapi Chatterjee, Nhan Nguyen and Philipas Tsigas. We will explore its correctness, progression factor, and the linearizability of its operations and report our findings. With a lock-free algorithm, software engineers will be able to use a thread-safe binary search tree that is capable of the many different operations that are normally available on a binary search tree. This includes the basic, primitive operations of Add(), Contains(), and Remove(), without the performance loss of using a binary search tree that uses object locking. An implementation of a binary search tree that uses locks to promote thread-safety takes a performance loss due to the threads waiting when another thread holds the lock and causing contention. The approach outlined in the aforementioned paper claims to have several key fundamental improvements over existing lock-free binary search tree algorithms. This implementation of the binary search tree eliminates contention in Contains() operations where, if a node was modified while a Contains() operation took place, the program would restart any current operation from the root of the tree. This happens because the thread can no longer reliably confide in the traversal of the tree and must restart its search. This is taxing to the performance of a binary search tree and an inefficient design can underperform a sequential implementation. Among other improvements, the authors of this paper claim that their algorithm is linearizable and has improved disjoint-access parallelism compared to similar existing algorithms.

BOUNDED SEARCH TREE ALGORITHMS FOR PARAMETRIZED COGRAPH DELETION: EFFICIENT BRANCHING RULES BY EXPLOITING STRUCTURES OF SPECIAL GRAPH CLASSES

2012 ◽  
Vol 04 (01) ◽  
pp. 1250008 ◽  
Author(s):  
JAMES NASTOS ◽  
YONG GAO
Keyword(s):  
Search Tree ◽  
Complex Case ◽  
Edge Deletion ◽  
Exponential Factor ◽  
Sparse Graphs ◽  
Graph Classes ◽  
Branching Rules ◽  
Fixed Parameter ◽  
Graph Class ◽  
Tree Algorithms

Many fixed-parameter tractable algorithms using a bounded search tree have been repeatedly improved, often by describing a larger number of branching rules involving an increasingly complex case analysis. We introduce a novel and general search strategy that branches on the forbidden subgraphs of a graph class relaxation. By using the class of P4-sparse graphs as the relaxed graph class, we obtain efficient bounded search tree algorithms for several parametrized deletion problems. We give the first non-trivial bounded search tree algorithms for the cograph edge-deletion problem and the trivially perfect edge-deletion problems. For the cograph vertex deletion problem, a refined analysis of the runtime of our simple bounded search algorithm gives a faster exponential factor than those algorithms designed with the help of complicated case distinctions and non-trivial running time analysis [R. Niedermeier and P. Rossmanith, An efficient fixed-parameter algorithm for 3-hitting set, J. Discrete Algorithms1(1) (2003) 89–102] and computer-aided branching rules [J. Gramm, J. Guo, F. Hüffner and R. Niedermeier, Automated generation of search tree algorithms for hard graph modification problems, Algorithmica39(4) (2004) 321–347].

Automated Generation of Search Tree Algorithms for Hard Graph Modification Problems

Algorithmica ◽  
2004 ◽  
Vol 39 (4) ◽  
pp. 321-347 ◽  
Author(s):  
Jens Gramm ◽  
Jiong Guo ◽  
Falk Hüffner ◽  
Rolf Niedermeier
Keyword(s):  
Search Tree ◽  
Graph Modification ◽  
Automated Generation ◽  
Tree Algorithms ◽  
Graph Modification Problems

Requirements Prioritization Techniques for Global Software Engineering

2017 ◽  
Vol 6 (1) ◽  
Author(s):  
Samina Saghir ◽  
Tasleem Mustafa
Keyword(s):  
Software Engineering ◽  
Requirements Engineering ◽  
Search Tree ◽  
Software Requirements ◽  
Binary Search Tree ◽  
Time Zone ◽  
Analytic Hierarchy ◽  
Requirements Prioritization ◽  
Global Software Engineering ◽  
Hierarchy Process

<p>Increase in globalization of the industry of software requires an exploration of requirements engineering (RE) in software development institutes at multiple locations. Requirements engineering task is very complicated when it is performed at single site, but it becomes too much complex when stakeholder groups define well-designed requirements under language, time zone and cultural limits. Requirements prioritization (RP) is considered as an imperative part of software requirements engineering in which requirements are ranked to develop best-quality software. In this research, a comparative study of the requirements prioritization techniques was done to overcome the challenges initiated by the corporal distribution of stakeholders within the organization at multiple locations. The objective of this study was to make a comparison between five techniques for prioritizing software requirements and to discuss the results for global software engineering. The selected techniques were Analytic Hierarchy Process (AHP), Cumulative Voting (CV), Value Oriented Prioritization (VOP), Binary Search Tree (BST), and Numerical Assignment Technique (NAT). At the end of the research a framework for Global Software Engineering (GSE) was proposed to prioritize the requirements for stakeholders at distributed locations.<strong></strong></p>

scholarly journals Bloom Filter-Based Parallel Architecture for Accelerating Equi-Join Operation on FPGA

Electronics ◽  
2021 ◽  
Vol 10 (15) ◽  
pp. 1778
Author(s):  
Binhao He ◽  
Meiting Xue ◽  
Shubiao Liu ◽  
Wei Luo
Keyword(s):  
Relational Databases ◽  
Parallel Architecture ◽  
Operation Time ◽  
Bloom Filter ◽  
Search Tree ◽  
Binary Search Tree ◽  
Maximum Acceleration ◽  
Data Intensive ◽  
Match Rate ◽  
Field Programmable

As one of the most important operations in relational databases, the join is data-intensive and time-consuming. Thus, offloading this operation using field-programmable gate arrays (FPGAs) has attracted much interest and has been broadly researched in recent years. However, the available SRAM-based join architectures are often resource-intensive, power-consuming, or low-throughput. Besides, a lower match rate does not lead to a shorter operation time. To address these issues, a Bloom filter (BF)-based parallel join architecture is presented in this paper. This architecture first leverages the BF to discard the tuples that are not in the join result and classifies the remaining tuples into different channels. Second, a binary search tree is used to reduce the number of comparisons. The proposed method was implemented on a Xilinx FPGA, and the experimental results show that under a match rate of 50%, our architecture achieved a high join throughput of 145.8 million tuples per second and a maximum acceleration factor of 2.3 compared to the existing SRAM-based join architectures.

scholarly journals Beyond Binary Search: Parallel In-place Construction of Implicit Search Tree Layouts

2021 ◽  
pp. 1-1
Author(s):  
Kyle Berney ◽  
Henri Casanova ◽  
Ben Karsin ◽  
Nodari Sitchinava
Keyword(s):  
Search Tree ◽  
Binary Search

scholarly journals Preconditioning methods based on spanning tree algorithms

2021 ◽  
Vol 1715 ◽  
pp. 012005
Author(s):  
D V Perevozkin ◽  
G A Omarova
Keyword(s):  
Spanning Tree ◽  
Tree Algorithms
Sign in / Sign up

Export Citation Format

Share Document