Showing papers on "Binary tree published in 2012"
03 Mar 2012
TL;DR: A new design for increasing the concurrency of kernel operations on a shared address space is contributed by exploiting read-copy-update (RCU) so that soft page faults can both run in parallel with operations that mutate the same address space and avoid contending with other page faults on shared cache lines.
Abstract: Software developers commonly exploit multicore processors by building multithreaded software in which all threads of an application share a single address space. This shared address space has a cost: kernel virtual memory operations such as handling soft page faults, growing the address space, mapping files, etc. can limit the scalability of these applications. In widely-used operating systems, all of these operations are synchronized by a single per-process lock. This paper contributes a new design for increasing the concurrency of kernel operations on a shared address space by exploiting read-copy-update (RCU) so that soft page faults can both run in parallel with operations that mutate the same address space and avoid contending with other page faults on shared cache lines. To enable such parallelism, this paper also introduces an RCU-based binary balanced tree for storing memory mappings. An experimental evaluation using three multithreaded applications shows performance improvements on 80 cores ranging from 1.7x to 3.4x for an implementation of this design in the Linux 2.6.37 kernel. The RCU-based binary tree enables soft page faults to run at a constant cost with an increasing number of cores,suggesting that the design will scale well beyond 80 cores.
137 citations
25 Jun 2012
TL;DR: Experimental evidence shows this parallel binary search tree algorithm built using single-word reads, writes, and compare-and-swap to be fast when compared with alternative solutions and scalable to large numbers of concurrently executing threads.
Abstract: Recent work on concurrent search trees has yielded solutions which either rely on locking parts of the data structure or exhibit suboptimal memory use. Trees are typically non-trivial to parallelise due to having multiple mutable fields per node but their average search time relative to simpler structures like linked-lists makes them desirable. We present a parallel binary search tree algorithm built using single-word reads, writes, and compare-and-swap. In this algorithm, operations will only contend if concurrent updates affect the same node(s). Updates are non-blocking as threads can complete each other's operations if necessary and each operation is linearisable. Experimental evidence shows it to be fast when compared with alternative solutions and scalable to large numbers of concurrently executing threads. It outperforms concurrent skip lists in the majority of scenarios tested; showing 65% more throughput when the performance difference of every experiment is averaged, and its memory footprint is significantly smaller than that of the other structures tested.
97 citations
TL;DR: This work presents an algorithmic framework, the hierarchical loop decomposition, that allows mapping loopy networks to binary trees, preserving in the connectivity of the trees the architecture of the original graph, and performs a quantitative statistical comparison between predictions of theoretical models and naturally occurring loopy graphs.
Abstract: Biology presents many examples of planar distribution and structural networks having dense sets of closed loops. An archetype of this form of network organization is the vasculature of dicotyledonous leaves, which showcases a hierarchically-nested architecture containing closed loops at many different levels. Although a number of approaches have been proposed to measure aspects of the structure of such networks, a robust metric to quantify their hierarchical organization is still lacking. We present an algorithmic framework, the hierarchical loop decomposition, that allows mapping loopy networks to binary trees, preserving in the connectivity of the trees the architecture of the original graph. We apply this framework to investigate computer generated graphs, such as artificial models and optimal distribution networks, as well as natural graphs extracted from digitized images of dicotyledonous leaves and vasculature of rat cerebral neocortex. We calculate various metrics based on the asymmetry, the cumulative size distribution and the Strahler bifurcation ratios of the corresponding trees and discuss the relationship of these quantities to the architectural organization of the original graphs. This algorithmic framework decouples the geometric information (exact location of edges and nodes) from the metric topology (connectivity and edge weight) and it ultimately allows us to perform a quantitative statistical comparison between predictions of theoretical models and naturally occurring loopy graphs.
83 citations
03 Sep 2012
TL;DR: This work introduces a divisive clustering algorithm that can efficiently extract a hierarchy over a large number of local trajectories and provides an efficient positive definite kernel that computes the structural and visual similarity of two tree decompositions by relying on models of their edges.
Abstract: We address the problem of recognizing complex activities, such as pole vaulting, which are characterized by the composition of a large and variable number of different spatio-temporal parts. We represent a video as a hierarchy of mid-level motion components. This hierarchy is a data-driven decomposition specific to each video. We introduce a divisive clustering algorithm that can efficiently extract a hierarchy over a large number of local trajectories. We use this structure to represent a video as an unordered binary tree. This tree is modeled by nested histograms of local motion features. We provide an efficient positive definite kernel that computes the structural and visual similarity of two tree decompositions by relying on models of their edges. Contrary to most approaches based on action decompositions, we propose to use the full hierarchical action structure instead of selecting a small fixed number of parts. We present experimental results on two recent challenging benchmarks that focus on complex activities and show that our kernel on per-video hierarchies allows to efficiently discriminate between complex activities sharing common action parts. Our approach improves over the state of the art, including unstructured activity models, baselines using other motion decomposition algorithms, graph matching, and latent models explicitly selecting a fixed number of parts.
75 citations
25 Feb 2012
TL;DR: In this paper, the authors introduce the first binary search tree algorithm designed for speculative executions and show that their speculation-friendly tree outperforms the existing transaction-based version of the AVL and the red-black trees.
Abstract: We introduce the first binary search tree algorithm designed for speculative executions. Prior to this work, tree structures were mainly designed for their pessimistic (non-speculative) accesses to have a bounded complexity. Researchers tried to evaluate transactional memory using such tree structures whose prominent example is the red-black tree library developed by Oracle Labs that is part of multiple benchmark distributions. Although well-engineered, such structures remain badly suited for speculative accesses, whose step complexity might raise dramatically with contention.We show that our speculation-friendly tree outperforms the existing transaction-based version of the AVL and the red-black trees. Its key novelty stems from the decoupling of update operations: they are split into one transaction that modifies the abstraction state and multiple ones that restructure its tree implementation in the background. In particular, the speculation-friendly tree is shown correct, reusable and it speeds up a transaction-based travel reservation application by up to 3.5x.
74 citations
TL;DR: In this article, a new construction of a Hopf algebra whose bases are indexed by objects belonging to the Baxter combinatorial family (i.e., Baxter permutations, pairs of binary trees, etc.).
64 citations
TL;DR: Experimental results indicate that the proposed adaptive binary tree SVM classifier outperforms other existing multi-class SVM strategies and is a novel approach to improve the accuracy of hyperspectral image classification and expand the possibilities for interpretation and application of hyperspected remote sensing image.
48 citations
TL;DR: The results of the simulations suggest that, with exact gene trees obtained by a simple birth-and-death process and realistic gene duplication/loss rates, a very small subset of all reconciliations needs to be explored in order to approximate very closely the posterior probability of the most likely reconciliation.
Abstract: Background. Inferring an evolutionary scenario for a gene family is a fundamental problem with applications both in functional and evolutionary genomics. The gene tree/species tree reconciliation approach has been widely used to address this problem, but mostly in a discrete parsimony framework that aims at minimizing the number of gene duplications and/or gene losses. Recently, a probabilistic approach has been developed, based on the classical birth-and-death process, including efficient algorithms for computing posterior probabilities of reconciliations and orthology prediction. Results. In previous work, we described an algorithm for exploring the whole space of gene tree/species tree reconciliations, that we adapt here to compute efficiently the posterior probability of such reconciliations. These posterior probabilities can be either computed exactly or approximated, depending on the reconciliation space size. We use this algorithm to analyze the probabilistic landscape of the space of reconciliations for a real data set of fungal gene families and several data sets of synthetic gene trees. Conclusion. The results of our simulations suggest that, with exact gene trees obtained by a simple birth-and-death process and realistic gene duplication/loss rates, a very small subset of all reconciliations needs to be explored in order to approximate very closely the posterior probability of the most likely reconciliations. For cases where the posterior probability mass is more evenly dispersed, our method allows to explore efficiently the required subspace of reconciliations.
41 citations
10 Apr 2012
TL;DR: The Context Tree Switching technique as discussed by the authors is a modification of Context Tree Weighting for the prediction of binary, stationary, n-Markov sources, which can mix over a strictly larger class of models without increasing the asymptotic time or space complexity.
Abstract: This paper describes the Context Tree Switching technique, a modification of Context Tree Weighting for the prediction of binary, stationary, n-Markov sources. By modifying Context Tree Weighting's recursive weighting scheme, it is possible to mix over a strictly larger class of models without increasing the asymptotic time or space complexity of the original algorithm. We prove that this generalization preserves the desirable theoretical properties of Context Tree Weighting on stationary n-Markov sources, and show empirically that this new technique leads to consistent improvements over Context Tree Weighting as measured on the Calgary Corpus.
40 citations
20 Aug 2012
TL;DR: Two succinct representations of binary trees that can be used to represent the Cartesian tree of an array A of size n are provided and it is shown that the pre-processing needed to output the data structure can be performed in linear time using o(n) bits of extra working space.
Abstract: We provide two succinct representations of binary trees that can be used to represent the Cartesian tree of an array A of size n. Both the representations take the optimal 2n + o(n) bits of space in the worst case and support range minimum queries (RMQs) in O(1) time. The first one is a modification of the representation of Farzan and Munro (SWAT 2008); a consequence of this result is that we can represent the Cartesian tree of a random permutation in 1.92n + o(n) bits in expectation. The second one uses a well-known transformation between binary trees and ordinal trees, and ordinal tree operations to effect operations on the Cartesian tree. This provides an alternative, and more natural, way to view the 2D-Min-Heap of Fischer and Huen (SICOMP 2011). Furthermore, we show that the pre-processing needed to output the data structure can be performed in linear time using o(n) bits of extra working space, improving the result of Fischer and Heun who use n + o(n) bits working space.
39 citations
07 Oct 2012
TL;DR: The method creates good sparse representations by using it in the object recognition framework of [1,2], and implements its own fast version of the SIFT descriptor the whole system runs at 20 frames per second on 321 ×481 sized images on a laptop with a quad-core cpu.
Abstract: We describe a method for fast approximation of sparse coding. A given input vector is passed through a binary tree. Each leaf of the tree contains a subset of dictionary elements. The coefficients corresponding to these dictionary elements are allowed to be nonzero and their values are calculated quickly by multiplication with a precomputed pseudoinverse. The tree parameters, the dictionary, and the subsets of the dictionary corresponding to each leaf are learned. In the process of describing this algorithm, we discuss the more general problem of learning the groups in group structured sparse modeling. We show that our method creates good sparse representations by using it in the object recognition framework of [1,2]. Implementing our own fast version of the SIFT descriptor the whole system runs at 20 frames per second on 321 ×481 sized images on a laptop with a quad-core cpu, while sacrificing very little accuracy on the Caltech 101, Caltech 256, and 15 scenes benchmarks.
TL;DR: This work provides a new analysis of the greedy algorithm that uses a simple accounting scheme to spread the cost of a tree among pairs of items split at a particular node and decreases the previous best upper bound on the approximation ratio by a constant factor.
Abstract: We give a (ln n+1)-approximation for the decision tree (DT) problem. An instance of DT is a set of m binary tests T=(T 1,…,T m ) and a set of n items X=(X 1,…,X n ). The goal is to output a binary tree where each internal node is a test, each leaf is an item and the total external path length of the tree is minimized. Total external path length is the sum of the depths of all the leaves in the tree. DT has a long history in computer science with applications ranging from medical diagnosis to experiment design. It also generalizes the problem of finding optimal average-case search strategies in partially ordered sets which includes several alphabetic tree problems. Our work decreases the previous best upper bound on the approximation ratio by a constant factor. We provide a new analysis of the greedy algorithm that uses a simple accounting scheme to spread the cost of a tree among pairs of items split at a particular node. We conclude by showing that our upper bound also holds for the DT problem with weighted tests.
TL;DR: The exact moments of the number of 2-protected nodes in binary search trees grown from random permutations are derived using a properly normalized version of this tree parameter.
TL;DR: This paper studies the possibility of exploiting several symmetries for speeding up the solution of DMDGPs, and proposes an extension of the BP algorithm that is named symmetry-driven BP (symBP), and Computational experiments on artificial and protein instances are presented.
Abstract: The Discretizable Molecular Distance Geometry Problem (DMDGP) involves a subset of instances of the distance geometry problem for which some assumptions allowing for discretization are satisfied. The search domain for the DMDGP is a binary tree that can be efficiently explored by employing a Branch & Prune (BP) algorithm. We showed in recent works that this binary tree may contain several symmetries, which are directly related to the total number of solutions of DMDGP instances. In this paper, we study the possibility of exploiting these symmetries for speeding up the solution of DMDGPs, and propose an extension of the BP algorithm that we named symmetry-driven BP (symBP). Computational experiments on artificial and protein instances are presented.
TL;DR: The extremal tree which minimizes the total number of subtrees among the set of all $q-ary trees with $n$ non-leaf vertices is identified and the extremal $n-vertex tree with given domination number maximizing the totalNumber of subtree is characterized.
Abstract: When considering the total number of subtrees of trees, the extremal structures which maximize this number among binary trees and trees with a given maximum degree lead to some interesting facts that correlate to some other graphical indices in applications. Along this line, it is interesting to study that over some types of trees with a given order, which trees minimize or maximize this number. Here are our main results: (1) The extremal tree which minimizes the total number of subtrees among $n$-vertex trees with $k$ pendants is characterized. (2) The extremal tree which maximizes (resp. minimizes) the total number of subtrees among $n$-vertex trees with a given bipartition is characterized. (3) The extremal tree which minimizes the total number of subtrees among the set of all $q$-ary trees with $n$ non-leaf vertices is identified. (4) The extremal $n$-vertex tree with given domination number maximizing the total number of subtrees is characterized.
TL;DR: In this article, the authors introduce a framework that encompasses Markov chains and characterize their asymptotic behavior by analyzing in detail their Doob-Martin compactifications, Poisson boundaries and tail $\sigma$-fields.
Abstract: It is possible to represent each of a number of Markov chains as an evolving sequence of connected subsets of a directed acyclic graph that grow in the following way: initially, all vertices of the graph are unoccupied, particles are fed in one-by-one at a distinguished source vertex, successive particles proceed along directed edges according to an appropriate stochastic mechanism, and each particle comes to rest once it encounters an unoccupied vertex. Examples include the binary and digital search tree processes, the random recursive tree process and generalizations of it arising from nested instances of Pitman's two-parameter Chinese restaurant process, tree-growth models associated with Mallows' $\phi$ model of random permutations and with Schutzenberger's non-commutative $q$-binomial theorem, and a construction due to Luczak and Winkler that grows uniform random binary trees in a Markovian manner. We introduce a framework that encompasses such Markov chains, and we characterize their asymptotic behavior by analyzing in detail their Doob-Martin compactifications, Poisson boundaries and tail $\sigma$-fields.
TL;DR: In this paper, the enumeration of binary trees avoiding non-contiguous binary tree patterns was studied, and it was shown that there is exactly one Wilf class of k-leaf tree patterns for any positive integer k.
Abstract: In this paper we consider the enumeration of binary trees avoiding non-contiguous binary tree patterns. We begin by computing closed formulas for the number of trees avoiding a single binary tree pattern with 4 or fewer leaves and compare these results to analogous work for contiguous tree patterns. Next, we give an explicit generating function that counts binary trees avoiding a single non-contiguous tree pattern according to number of leaves and show that there is exactly one Wilf class of k-leaf tree patterns for any positive integer k. In addition, we give a bijection between between certain sets of pattern-avoiding trees and sets of pattern-avoiding permutations. Finally, we enumerate binary trees that simultaneously avoid more than one tree pattern.
TL;DR: A Bayesian uncertainty quantification framework using a local binary tree surrogate model that is able to make use of arbitrary Bayesian regression methods and is demonstrated with examples in the solution of stochastic differential equations.
Abstract: We develop a Bayesian uncertainty quantification framework using a local binary tree surrogate model that is able to make use of arbitrary Bayesian regression methods. The tree is adaptively constructed using information about the sensitivity of the response and is biased by the underlying input probability distribution. The local Bayesian regressions are based on a reformulation of the relevance vector machine model that accounts for the multiple output dimensions. A fast algorithm for training the local models is provided. The methodology is demonstrated with examples in the solution of stochastic differential equations.
TL;DR: The second order correction for the cover time of the binary tree of depth n is computed by (continuous-time) random walk, and it is shown that with probability approaching 1 as n increases, τcov=|E|[2log2⋅n−logn/2 log2+O((loglogn)8)], thus showing that the second order Correction differs from the corresponding one for the maximum of the Gaussian free field on the tree.
TL;DR: In this article, a parametrization of undirected discrete graphical tree models was proposed, where leaves represent the observable variables and all the inner nodes are unobserved, and the construction of the proposed coordinate system mirrors the combinatorial definition of cumulants.
Abstract: In this paper we investigate undirected discrete graphical tree models when all the variables in the system are binary, where leaves represent the observable variables and where all the inner nodes are unobserved. A novel approach based on the theory of partially ordered sets allows us to obtain a convenient parametrization of this model class. The construction of the proposed coordinate system mirrors the combinatorial definition of cumulants. A simple product-like form of the resulting parametrization gives insight into identifiability issues associated with this model class. In particular, we provide necessary and sufficient conditions for such a model to be identified up to the switching of labels of the inner nodes. When these conditions hold, we give explicit formulas for the parameters of the model. Whenever the model fails to be identified, we use the new parametrization to describe the geometry of the unidentified parameter space. We illustrate these results using a simple example.
TL;DR: New heuristics, based on the Edge Contract and Refine (ECR) operation, that remove this restriction, thereby expanding the utility of RF supertrees and show that the unrooted local search algorithms yield bettersupertrees than those obtained from MRP and rooted RF heuristic in terms of total RF distance to the input trees.
Abstract: A Robinson-Foulds (RF) supertree for a collection of input trees is a tree containing all the species in the input trees that is at minimum total RF distance to the input trees. Thus, an RF supertree is consistent with the maximum number of splits in the input trees. Constructing RF supertrees for rooted and unrooted data is NP-hard. Nevertheless, effective local search heuristics have been developed for the restricted case where the input trees and the supertree are rooted. We describe new heuristics, based on the Edge Contract and Refine (ECR) operation, that remove this restriction, thereby expanding the utility of RF supertrees. Our experimental results on simulated and empirical data sets show that our unrooted local search algorithms yield better supertrees than those obtained from MRP and rooted RF heuristics in terms of total RF distance to the input trees and, for simulated data, in terms of RF distance to the true tree.
TL;DR: The binary tree is proposed as a novel and robust way of coding remote sensing image in wavelet domain and an adaptive scanning order to traverse the binary tree level by level from the bottom to the top is developed so that better performance and visual effect are attained.
Abstract: Remote sensing images offer a large amount of information but require on-board compression because of the storage and transmission constraints of on-board equipment. JPEG2000 is too complex to become a recommended standard for the mission, and CCSDS-IDC fixes most of the parameters and only provides quality scalability. In this paper, we present a new, low-complexity, low-memory, and efficient embedded wavelet image codec for on-board compression. First, we propose the binary tree as a novel and robust way of coding remote sensing image in wavelet domain. Second, we develop an adaptive scanning order to traverse the binary tree level by level from the bottom to the top, so that better performance and visual effect are attained. Last, the proposed method is processed with a scan-based mode, which significantly reduces the memory requirement. The proposed method is very fast because it does not use any entropy coding and rate-distortion optimization, while it provides quality, position, and resolution scalability. Being less complex, it is very easy to implement in hardware and very suitable for on-board compression. Experimental results show that the proposed method can significantly improve peak signal-to-noise ratio compared with SPIHT without arithmetic coding and scan-based CCSDS-IDC, and is similar to scan-based JPEG2000.
Patent•
18 Apr 2012
TL;DR: In this article, an anomaly detection method for various kinds of intrusion is proposed, which comprises the following steps of: 1) preprocessing an original data set, identifying a complete request message, and dividing network connection through service type to extract relevant characteristics; 2) analyzing the characteristics of all kinds of attack by a characteristic extraction unit, and by using application layer information during consideration of relevant fields on the head of a data packet, extracting three characteristics, namely basic characteristics, flow characteristics and content characteristics.
Abstract: The invention discloses an anomaly detection method for various kinds of intrusion. The method comprises the following steps of: 1) pre-processing an original data set, identifying a complete request message, and dividing network connection through service type to extract relevant characteristics; 2) by analyzing the characteristics of all kinds of attack by a characteristic extraction unit, and by using application layer information during consideration of relevant fields on the head of a data packet, extracting three characteristics, namely basic characteristics, flow characteristics and content characteristics; 3) by using an attribute reduction algorithm based on a discernibility matrix, processing attributes of a great number of extracted data characteristics, deleting redundant attributes in the attributes to obtain a reduced attribute set, extracting data from original training data according to the reduced attribute set to obtain new training data, and transmitting the new training data to a support vector machine (SVM) module for training and classification; and 4) by using a multi-classification SVM method based on a binary tree, classifying minimum attribute sub-sets after reduction of a rough set to realize a quick classification function of intrusion detection.
TL;DR: This new OCCT topology is based on the Chained-Cubic Tree (CCT) interconnection network and is designed to cope with both types of binary trees; full and complete.
TL;DR: It is shown that the maximization version of the dual problem for binary trees can be reduced to a version of MaxCut for which the algorithm of Goemans and Williamson yields a 0.878-approximation.
Abstract: A binary tanglegram is a drawing of a pair of rooted binary trees whose leaf sets are in one-to-one correspondence; matching leaves are connected by inter-tree edges. For applications, for example, in phylogenetics, it is essential that both trees are drawn without edge crossings and that the inter-tree edges have as few crossings as possible. It is known that finding a tanglegram with the minimum number of crossings is NP-hard and that the problem is fixed-parameter tractable with respect to that number.
We prove that under the Unique Games Conjecture there is no constant-factor approximation for binary trees. We show that the problem is NP-hard even if both trees are complete binary trees. For this case we give an O(n 3)-time 2-approximation and a new, simple fixed-parameter algorithm. We show that the maximization version of the dual problem for binary trees can be reduced to a version of MaxCut for which the algorithm of Goemans and Williamson yields a 0.878-approximation.
TL;DR: A simple semantic restriction called "thrifty" on -way branching programs solving tree evaluation problems is introduced, and the same state bound of Θh) is tight for all
Abstract: We introduce the tree evaluation problem, show that it is in LogDCFL (and hence in P), and study its branching program complexity in the hope of eventually proving a superlogarithmic space lower bound. The input to the problem is a rooted, balanced d-ary tree of height h, whose internal nodes are labeled with d-ary functions on [k] = {1,..., k}, and whose leaves are labeled with elements of [k]. Each node obtains a value in [k] equal to its d-ary function applied to the values of its d children. The output is the value of the root. We show that the standard black pebbling algorithm applied to the binary tree of height h yields a deterministic k-way branching program with O(kh) states solving this problem, and we prove that this upper bound is tight for h = 2 and h = 3. We introduce a simple semantic restriction called thrifty on k-way branching programs solving tree evaluation problems and show that the same state bound of Θ(kh) is tight for all h ≥ 2 for deterministic thrifty programs. We introduce fractional pebbling for trees and show that this yields nondeterministic thrifty programs with Θ(kh/2+1) states solving the Boolean problem “determine whether the root has value 1”, and prove that this bound is tight for h = 2,3,4. We also prove that this same bound is tight for unrestricted nondeterministic k-way branching programs solving the Boolean problem for h = 2,3.
TL;DR: The indiscernibility of trees A in general settings is studied and the obtained results are applied to the study of unstable theories.
TL;DR: It is proved that, for every fixed k ≥ 0, it is polynomial-time solvable to construct a phylogenetic network with level equal to k representing a cluster set, or to determine that no such network exists.
Abstract: Rooted phylogenetic networks are often used to represent conflicting phylogenetic signals. Given a set of clusters, a network is said to represent these clusters in the softwired sense if, for each cluster in the input set, at least one tree embedded in the network contains that cluster. Motivated by parsimony we might wish to construct such a network using as few reticulations as possible, or minimizing the level of the network, i.e., the maximum number of reticulations used in any "tangled” region of the network. Although these are NP-hard problems, here we prove that, for every fixed k \ge 0, it is polynomial-time solvable to construct a phylogenetic network with level equal to k representing a cluster set, or to determine that no such network exists. However, this algorithm does not lend itself to a practical implementation. We also prove that the comparatively efficient Cass algorithm correctly solves this problem (and also minimizes the reticulation number) when input clusters are obtained from two not necessarily binary gene trees on the same set of taxa but does not always minimize level for general cluster sets. Finally, we describe a new algorithm which generates in polynomial-time all binary phylogenetic networks with exactly r reticulations representing a set of input clusters (for every fixed r \ge 0).
TL;DR: This paper considers the problem of embedding hypercubes into k-rooted complete binary trees, k- rooted sibling trees, binomial trees and certain classes of caterpillars to minimize the wirelength.
TL;DR: A novel tag anti-collision protocol (ACQT), which is suitable for a large mobile tags environment, based on a 3-ary tree, which has the optimal capacity to identify for tree-based protocols.
Abstract: A reader must be able to identify tags as quickly as possible, so tag anti-collision is a significant issue for the RFID system. In this paper, we propose a novel tag anti-collision protocol (ACQT), which is suitable for a large mobile tags environment. Based on a 3-ary tree, it has the optimal capacity to identify for tree-based protocols. Using a combination query tree, it can solve the problem of not being able to generate a 3-ary tree when the length of a tag's ID is not a multiple of 3. The joining and leaving strategies can efficiently be applied for tag mobility. The simulation results show that the protocol we present can achieve better performance than previous protocols by decreasing identification delay, collision cycles and idle cycles.