精华内容
下载资源
问答
  • 动态二进制树搜索算法 二进制搜索树 (Binary Search Tree) A binary search tree is a useful data structure for fast addition and removal of data. 二进制搜索树是用于快速添加和删除数据的有用数据结构。 It...

    动态二进制树搜索算法

    A binary search tree is a useful data structure for fast addition and removal of data.

    二进制搜索树是用于快速添加和删除数据的有用数据结构。

    It is composed of nodes, which stores data and also links to upto two other child nodes. It is the relationship between the leaves linked to and the linking leaf, also known as the parent node, which makes the binary tree such an efficient data structure.

    它由节点组成,节点存储数据并链接到最多两个其他子节点。 链接到的叶子与链接叶子(也称为父节点)之间的关系使二叉树成为一种高效的数据结构。

    For a binary tree to be a binary search tree, the data of all the nodes in the left sub-tree of the root node should be less than the data of the root. The data of all the nodes in the right subtree of the root node should be greater than equal to the data of the root. As a result, the leaves on the farthest left of the tree have the lowest values, whereas the leaves on the right of the tree have the greatest values.

    为了使二叉树成为二叉搜索树,根节点左子树中所有节点的数据应小于根节点的数据。 根节点右子树中所有节点的数据应大于等于根节点的数据。 结果,树最左边的叶子具有最低的值,而树右边的叶子具有最大的值。

    A representation of binary search tree looks like the following:

    二进制搜索树的表示形式如下所示:

    Binary Search Tree

    Consider the root node 20. All elements to the left of subtree(10, 5) are less than 20 and all elements to the right of subtree(25, 30, 35) are greater than 20.

    考虑根节点20。子树(10,5)左侧的所有元素都小于20,子树(25,30,35)右侧的所有元素都大于20。

    实施BST (Implementation of BST)

    First, define a struct as tree_node. It will store the data and pointers to left and right subtree.

    首先,将一个结构定义为tree_node 。 它将存储数据以及指向左和右子树的指针。

    struct tree_node
    {
    	int data;
    	tree_node *left, *right;
    };

    The node itself is very similar to the node in a linked list. A basic knowledge of the code for a linked list will be very helpful in understanding the techniques of binary trees.

    该节点本身与链表中的节点非常相似。 链表代码的基本知识将有助于理解二叉树的技术。

    It is most logical to create a binary search tree class to encapsulate the workings of the tree into a single area, and also making it reusable. The class will contain functions to insert data into the tree, search if the data is present and methods for traversing the tree.

    创建二进制搜索树类以将树的工作封装到单个区域中并使其可重用是最合乎逻辑的。 该类将包含将数据插入树中,搜索数据是否存在以及遍历树的方法的函数。

    class BST
    {
    	tree_node *root;
    	void insert(tree_node* , int );
    	bool search(int , tree_node* );
    	void inorder(tree_node* );
    	void preorder(tree_node* );
    	void postorder(tree_node* );
    
    	public:
    	BST()
    	{
    		root = NULL;
    	}
    	void insert(int );
    	bool search(int key);
        void inorder();
        void preorder();
        void postorder();
    };

    It is necessary to initialize root to NULL for the later functions to be able to recognize that it does not exist.

    必须将root初始化为NULL,以便以后的功能能够识别它不存在。

    All the public members of the class are designed to allow the user of the class to use the class without dealing with the underlying design. The functions which will be called recursively are the ones which are private, allowing them to travel down the tree.

    该类的所有公共成员都被设计为允许该类的用户使用该类,而无需处理基础设计。 将被递归调用的函数是私有的,从而使它们可以向下移动。

    插入BST (Insertion in a BST)

    To insert data into a binary tree involves a function searching for an unused node in the proper position in the tree in which to insert the key value. The insert function is generally a recursive function that continues moving down the levels of a binary tree until there is an unused leaf in a position which follows the following rules of placing nodes.

    将数据插入二叉树涉及到一个函数,该函数在树中要插入键值的适当位置中搜索未使用的节点。 插入函数通常是递归函数,它继续向下移动二叉树的级别,直到某个位置上有未使用的叶子为止,该叶子遵循以下放置节点的规则。

    • Compare data of the root node and element to be inserted.

      比较根节点和要插入的元素的数据。

    • If the data of the root node is greater, and if a left subtree exists, then repeat step 1 with root = root of left subtree. Else,

      如果根节点的数据更大,并且存在左子树,则使用root = left subtree的root重复步骤1。 其他,

    • Insert element as left child of current root.

      插入元素作为当前根的左子元素。

    • If the data of the root node is greater, and if a right subtree exists, then repeat step 1 with root = root of right subtree.

      如果根节点的数据更大,并且存在右子树,则使用root = right subtree的root重复步骤1。

    • Else, insert element as right child of current root.

      否则,将元素插入为当前根的右子元素。

    Binary Search Tree
    void BST :: insert(tree_node *node, int d)
    {
    	// element to be inserted is lesser than node’s data
    	if(d < node->data)
    	{
    		// if left subtree is present
    		if(node->left != NULL)
    			insert(node->left, d);
    		
    		// create new node
    		else
    		{
    			node->left = new tree_node;
    			node->left->data = d;
    			node->left->left = NULL;
    			node->left->right = NULL;
    		}
    	}
    
    	// element to be inserted is greater than node’s data
    	else if(d >= node->data)
    	{
    		// if left subtree is present
    		if(node->right != NULL)
    			insert(node->right, d);
    		
    		// create new node
    		else
    		{
    			node->right = new tree_node;
    			node->right->data = d;
    			node->right->left = NULL;
    			node->right->right = NULL;
    		}
    	}
    	
    }

    Since the root node is a private member, we also write a public member function which is available to non-members of the class. It calls the private recursive function to insert an element and also takes care of the case when root node is NULL.

    由于根节点是私有成员,因此我们还编写了一个公共成员函数,该函数可供该类的非成员使用。 它调用私有递归函数来插入元素,并且还要注意当根节点为NULL时的情况。

    void BST::insert(int d)
    {
    	if(root!=NULL)
                    insert(root, d);
    	else
        {
            root = new tree_node;
            root->data = d;
            root->left = NULL;
            root->right = NULL;
        }
    }

    在BST中搜索 (Searching in a BST)

    The search function works in a similar fashion as insert. It will check if the key value of the current node is the value to be searched. If not, it should check to see if the value to be searched for is less than the value of the node, in which case it should be recursively called on the left child node, or if it is greater than the value of the node, it should be recursively called on the right child node.

    搜索功能的工作方式与插入类似。 它将检查当前节点的键值是否为要搜索的值。 如果不是,则应检查要搜索的值是否小于节点的值,在这种情况下,应在左侧的子节点上递归调用该值,或者应大于节点的值,应该在正确的子节点上递归调用它。

    • Compare data of the root node and the value to be searched.

      比较根节点的数据和要搜索的值。

    • If the data of the root node is greater, and if a left subtree exists, then repeat step 1 with root = root of left subtree. Else,

      如果根节点的数据更大,并且存在左子树,则使用root = left subtree的root重复步骤1。 其他,

    • If the data of the root node is greater, and if a right subtree exists, then repeat step 1 with root = root of right subtree. Else,

      如果根节点的数据更大,并且存在右子树,则使用root = right subtree的root重复步骤1。 其他,

    • If the value to be searched is equal to the data of root node, return true.

      如果要搜索的值等于根节点的数据,则返回true。

    • Else, return false.

      否则,返回false。

    bool BST::search(int d, tree_node *node)
    {
    	bool ans = false;
    
    	// node is not present
      	if(node == NULL)
     		return false;
    	
    	// Node’s data is equal to value searched
        if(d == node->data)
          	return true;
    	
    	// Node’s data is greater than value searched
        else if(d < node->data)
           	ans = search(d, node->left);
    
    	// Node’s data is lesser than value searched
        else
           	ans = search(d, node->right);
      
        return ans;
    }

    Since the root node is a private member, we also write a public member function which is available to non-members of the class. It calls the private recursive function to search an element and also takes care of the case when root node is NULL.

    由于根节点是私有成员,因此我们还编写了一个公共成员函数,该函数可供该类的非成员使用。 它调用私有递归函数来搜索元素,并且还要注意根节点为NULL的情况。

    bool BST::search(int d)
    {
    	if(root ==  NULL)
    		return false;
    	else	
    		return  search(d, root);
    }

    在BST中遍历 (Traversing in a BST)

    There are mainly three types of tree traversals:

    树遍历主要有三种类型:

    1.预定遍历: (1. Pre-order Traversal:)

    In this technique, we do the following :

    在此技术中,我们执行以下操作:

    • Process data of root node.

      根节点的处理数据。

    • First, traverse left subtree completely.

      首先,完全遍历左子树。

    • Then, traverse right subtree.

      然后,遍历右子树。

    void BST :: preorder(tree_node *node)
    {
    	if(node !=  NULL)
        {
    		cout<<node->data<<endl;
           	preorder(node->left);
           	preorder(node->right);
        }
    }

    2.订单遍历 (2. Post-order Traversal)

    In this traversal technique we do the following:

    在这种遍历技术中,我们执行以下操作:

    • First traverse left subtree completely.

      完全遍历左子树。

    • Then, traverse right subtree completely.

      然后,完全遍历右子树。

    • Then, process data of node.

      然后,处理节点的数据。

    void BST :: postorder(tree_node *node)
    {
    	if(node !=  NULL)
       	{
            postorder(node->left);
            postorder(node->right);
    	    cout<<node->data<<endl;
       	}
    }

    3.有序遍历 (3. In-order Traversal)

    In in-order traversal, we do the following:

    在有序遍历中,我们执行以下操作:

    • First process left subtree.

      首先处理左子树。

    • Then, process current root node.

      然后,处理当前的根节点。

    • Then, process right subtree.

      然后,处理右子树。

    void BST :: inorder(tree_node *node)
    {
    	if(node !=  NULL)
       	{
            inorder(node->left);
    	    cout<<node->data<<endl;
            inorder(node->right);
       	}
    }

    The in-order traversal of a binary search tree gives a sorted ordering of the data elements that are present in the binary search tree. This is an important property of a binary search tree.

    二进制搜索树的有序遍历给出了二进制搜索树中存在的数据元素的排序顺序。 这是二进制搜索树的重要属性。

    Since the root node is a private member, we also write public member functions which is available to non-members of the class. It calls the private recursive function to traverse the tree and also takes care of the case when root node is NULL.

    由于根节点是私有成员,因此我们还编写了公共成员函数,该函数可供该类的非成员使用。 它调用私有递归函数遍历树,并且还照顾根节点为NULL的情况。

    void BST :: preorder()
    {
    	if(root ==  NULL)
    		cout<<"TREE IS  EMPTY\n";
    	else
           	preorder(root);
    }
    
    void BST :: postorder()
    {
    	if(root ==  NULL)
    		cout<<"TREE IS  EMPTY\n";
    	else
    	    postorder(root);
    }
    
    void BST :: inorder()
    {
    	if(root == NULL)
    		cout<<"TREE IS EMPTY\n";
    	else
    		inorder(root);
    }

    复杂度分析 (Complexity Analysis)

    Binary Search Tree

    The time complexity of search and insert rely on the height of the tree. On average, binary search trees with n nodes have O(log n) height. However in the worst case the tree can have a height of O(n) when the unbalanced tree resembles a linked list. For example in this case :

    搜索和插入的时间复杂度取决于树的高度。 平均而言,具有n个节点的二叉搜索树的高度为O(log n) 。 但是,在最坏的情况下,当不平衡树类似于链表时,树的高度可能为O(n) 。 例如在这种情况下:

    Binary Search Tree

    Traversal requires O(n) time, since every node must be visited.

    遍历需要O(n)时间,因为必须访问每个节点。

    翻译自: https://www.studytonight.com/data-structures/binary-search-tree

    动态二进制树搜索算法

    展开全文
  • 比如A: 10101010 B:10101000 读写器第一遍请求,得到的结果就是: 101010x0 这时候是直接得到两个标签的ID还是将x设为0再发送一次请求呢?
  • 二进制树型搜索算法 二进制搜索算法 (Binary Search Algorithm) Binary Search is applied on the sorted array or list of large size. It's time complexity of O(log n) makes it very fast as compared to ...

    二进制树型搜索算法

    Binary Search is applied on the sorted array or list of large size. It's time complexity of O(log n) makes it very fast as compared to other sorting algorithms. The only limitation is that the array or list of elements must be sorted for the binary search algorithm to work on it.

    二进制搜索应用于排序后的数组或大型列表。 O(log n)的时间复杂性使其与其他排序算法相比非常快。 唯一的限制是必须对元素的数组或列表进行排序,以便二进制搜索算法可以对其进行处理。

    实现二进制搜索算法 (Implementing Binary Search Algorithm)

    Following are the steps of implementation that we will be following:

    以下是我们将要执行的实现步骤:

    1. Start with the middle element:

      从中间元素开始:

      • target value is equal to the middle element of the array, then return the index of the middle element.目标值等于数组的中间元素,则返回中间元素的索引。
        • If the target value is greater than the number in the middle index, then pick the elements to the right of the middle index, and start with Step 1.
        • If the target value is less than the number in the middle index, then pick the elements to the left of the middle index, and start with Step 1.
    2. When a match is found, return the index of the element matched.

      找到匹配项后,返回匹配元素的索引。

    3. If no match is found, then return -1

      如果找不到匹配项,则返回-1

    /*
        function for carrying out binary search on given array
        - values[] => given sorted array
        - len => length of the array
        - target => value to be searched
    */
    int binarySearch(int values[], int len, int target)
    {
        int max = (len - 1);
        int min = 0;
        
        int guess;  // this will hold the index of middle elements
        int step = 0;  // to find out in how many steps we completed the search
        
        while(max >= min)
        {
            guess = (max + min) / 2;
            // we made the first guess, incrementing step by 1
            step++;
            
            if(values[guess] ==  target)
            {
                printf("Number of steps required for search: %d \n", step);
                return guess;
            }
            else if(values[guess] >  target) 
            {
                // target would be in the left half
                max = (guess - 1);
            }
            else
            {
                // target would be in the right half
                min = (guess + 1);
            }
        }
     
        // We reach here when element is not 
        // present in array
        return -1;
    }
     
    int main(void)
    {
        int values[] = {13, 21, 54, 81, 90};
        int n = sizeof(values) / sizeof(values[0]);
        int target = 81;
        int result = binarySearch(values, n, target);
        if(result == -1)
        {  
            printf("Element is not present in the given array.");
        }
        else
        {
            printf("Element is present at index: %d", result);
        }
        return 0;
    }

    We hope the above code is clear, if you have any confusion, post your question in our Q & A Forum.

    我们希望上面的代码清晰明了,如果您有任何疑问,请在我们的“ 问答论坛”中发布您的问题。

    Now let's try to understand, why is the time complexity of binary search O(log n) and how can we calculate the number of steps required to search an element from a given array using binary search without doing any calculations. It's super easy! Are you ready?

    现在让我们尝试理解,为什么二分查找的时间复杂度为O(log n),以及如何在不进行任何计算的情况下使用二分查找来计算从给定数组中搜索元素所需的步数。 超级容易! 你准备好了吗?

    二元搜索的时间复杂度O(log n) (Time Complexity of Binary Search O(log n))

    When we say the time complexity is log n, we actually mean log2 n, although the base of the log doesn't matter in asymptotic notations, but still to understand this better, we generally consider a base of 2.

    当我们说时间复杂度是log n ,我们实际上是指log 2 n ,尽管对数的底数在渐进表示法中并不重要,但是为了更好地理解这一点,我们通常考虑2的底数。

    Let's first understand what log2(n) means.

    首先让我们了解log 2 (n)含义。

    Expression: log2(n) - - - - - - - - - - - - - - - For n = 2: log2(21) = 1 Output = 1 - - - - - - - - - - - - - - - For n = 4 log2(22) = 2 Output = 2 - - - - - - - - - - - - - - - For n = 8 log2(23) = 3 Output = 3 - - - - - - - - - - - - - - - For n = 256 log2(28) = 8 Output = 8 - - - - - - - - - - - - - - - For n = 2048 log2(211) = 11 Output = 11

    表达式:log 2 (n)---------------对于n = 2:log 2 (2 1 )= 1输出= 1------------ ---对于n = 4 log 2 (2 2 )= 2输出= 2----------------对于n = 8 log 2 (2 3 )= 3输出= 3-- --------------对于n = 2048 log 2 (n = 256 log 2 (2 8 )= 8输出= 8---------------- 2 11 )= 11输出= 11

    Now that we know how log2(n) works with different values of n, it will be easier for us to relate it with the time complexity of the binary search algorithm and also to understand how we can find out the number of steps required to search any number using binary search for any value of n.

    现在我们知道如何log 2 (n)与不同价值观的作品n ,这将是我们更容易与二进制搜索算法的时间复杂度有关,同时还应了解我们如何能够找出需要的步数使用二进制搜索n任何值来搜索任何数字。

    计算步数 (Counting the Number of Steps)

    As we have already seen, that with every incorrect guess, binary search cuts down the list of elements into half. So if we start with 32 elements, after first unsuccessful guess, we will be left with 16 elements.

    正如我们已经看到的,每进行一次错误的guess ,二进制搜索就会将元素列表缩减为一半。 因此,如果我们从32个元素开始,则在第一次失败的猜测之后,我们将剩下16个元素。

    So consider an array with 8 elements, after the first unsuccessful, binary sort will cut down the list to half, leaving behind 4 elements, then 2 elements after the second unsuccessful guess, and finally only 1 element will be left, which will either be the target or not, checking that will involve one more step. So all in all binary search needed at most 4 guesses to search the target in an array with 8 elements.

    因此,考虑一个包含8个元素的数组,在第一个不成功的二进制排序之后,将列表减半,剩下4个元素,然后在第二个不成功的猜测之后保留2个元素,最后只剩下1个元素,或者是否达到target ,检查将涉及更多步骤。 因此,所有二进制搜索最多需要4个猜测才能在具有8个元素的数组中搜索target

    If the size of the list would have been 16, then after the first unsuccessful guess, we would have been left with 8 elements. And after that, as we know, we need atmost 4 guesses, add 1 guess to cut down the list from 16 to 8, that brings us to 5 guesses.

    如果列表的大小为16,则在第一次不成功的猜测之后,我们将剩下8个元素。 然后,据我们所知,我们最多需要4个猜测,再加上1个猜测就可以将列表从16个减少到8个,这使我们得到5个猜测。

    So we can say, as the number of elements are getting doubled, the number of guesses required to find the target increments by 1.

    因此,可以说,随着元素数量增加一倍,找到target所需的猜测数量将增加1

    Seeing the pattern, right?

    看到图案了吧?

    Generalizing this, we can say, for an array with n elements,

    概括地说,对于具有n元素的数组,

    n, until we get the value 1, plus one.n开始可以重复减半的次数,直到获得值1加1。

    And guess what, in mathematics, the function log2 n means exactly same. We have already seen how the log function works above, did you notice something there?

    并猜想在数学上,函数log 2 n含义是完全相同的。 我们已经在上面看到了log函数的工作方式,您在那儿注意到了吗?

    For n = 8, the output of log2 n comes out to be 3, which means the array can be halved 3 times maximum, hence the number of steps(at most) to find the target value will be (3 + 1) = 4.

    对于n = 8 ,对log 2 n的输出为3 ,这意味着该数组可以减半为最大3倍,因此(最多)查找目标值的步骤数将为(3 +1)= 4。

    Question for you: What will be the maximum number of guesses required by Binary Search, to search a number in a list of 2,097,152 elements?

    您的问题:二进制搜索要搜索2097152个元素列表中的数字,最大猜想数是多少?

    翻译自: https://www.studytonight.com/data-structures/binary-search-algorithm

    二进制树型搜索算法

    展开全文
  • 二进制树搜索算法 二进制搜索用于在 值的排序列表 。 它选择排序值数组中的中间元素,并将其与目标值进行比较; 这就是我们在数组中寻找的关键。 如果它小于目标值,则在中间元素之后搜索,直到数组末尾。 如果...

    二进制树形搜索算法

    二进制搜索用于在

    值的排序列表

    它选择排序值数组中的中间元素,并将其与目标值进行比较; 这就是我们在数组中寻找的关键。

    如果它小于目标值,则在中间元素之后搜索,直到数组末尾。 如果相等,则找到目标值并返回中间值。 否则,从数组的开头到中间-1进行搜索。 如果下限大于上限(确定搜索区域的上限),则目标值不在数组中。

    我提供了一个二进制搜索功能的示例代码。

     
    /**
     *
     *
     *    FILE: bsearch.h
     *
     *
     *    Description:
     *
     *        Function prototype for binarySearch function.
     *
     *
     */   
    #ifndef _bsearch_h   
    #define _bsearch_h     
    /**
     *
     *    Synopsis:
     *
     *        int binarySearch( int a[], int key, int size )
     *
     *
     *    Description:
     *
     *        Function binarySearch performs a binary search in a 
     *        sorted array a searching for a key.
     *
     *
     *    Parameters:
     *
     *        a[]: sorted array of integers.
     *
     *        key: key to be searched for in a[].
     *
     *        size: size of a[].
     *
     *
     *    Assertions:
     *
     *        none.
     *
     *
     *    Returns:
     *
     *        Function binarySearch returns -1 if key is not in a[].
     *        Otherwise in returns the i, for which a[ i ] == key.
     *
     *
     */
    int binarySearch( int a[], int key, int size );     
    #endif 
    
    /**
     *
     *
     *    FILE: binarySearch.c
     *
     *
     *    Description:
     *
     *        File contains binarySearch functions declared in bsearch.h file.
     *
     *
     */     
    #include "bsearch.h"     
    /**
     *------------------------------------------------------------
     *
     *    Function _binarySearch is called by binarySearch function with
     *    low = 0 and high = size - 1, to secure the search boundaries of 
     *    the array.
     *
     *------------------------------------------------------------
     */
    static int _binarySearch( int a[], int key, int low, int high );     
    int binarySearch( int a[], int key, int size ){   
        return ( _binarySearch( a, key, 0, size - 1 ) );   
    }    //    int binarySearch( int a[], int key, int size )    
    /**
     *------------------------------------------------------------
     *
     *    Search key value in a[].
     *
     *------------------------------------------------------------
     */
    static int _binarySearch( int a[], int key, int low, int high ){   
        if ( low > high ){   
            return ( -1 );                                /** key not found in a[]                                                */   
        }
        else{   
            int middle = ( low + high ) / 2;   
            if ( a[ middle ] == key ){   
                return ( middle );                        /** key found in a[]                                                    */   
            }
            else if ( a[ middle ] < key ){   
                /**
                 *
                 *    key we are searching is larger than the value of a[ middle ]
                 *    and since array is sorted, the search will continue in the side
                 *    after the middle index; that is from middle + 1 till high.
                 *
                 */
                return ( _binarySearch( a, key, middle + 1, high ) );   
            }
            else{   
                /**
                 *
                 *    key we are searching is lower than the value of a[ middle ]
                 *    and since array is sorted, the search will continue in the side
                 *    before the middle index; that is from low till high - 1.
                 *
                 */
                return ( _binarySearch( a, key, low, middle - 1 ) );   
            }   
        }   
    }    //    static int _binarySearch( int a[], int key, int low, int high ) 
    
    /**
     *
     *
     *    FILE: main.c
     *
     *
     *    Description:
     *
     *        Test binarySearch function.
     *
     *
     */     
    #include "bsearch.h"   
    #include <assert.h>     
    /**
     *
     *    Simple check for binarySearch function
     *
     */
    int main( void ){   
        int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };   
        int i;   
        for ( i = 0 ; i < 21 ; ++i ){   
            assert( binarySearch( a, i, 21 ) == i );   
        }   
        for ( ; i < 50 ; ++i ){   
            assert( binarySearch( a, i, 21 ) == -1 );   
        }   
        return ( 0 );   
    }    //    int main( void ) 

    翻译自: https://bytes.com/topic/c/insights/799745-binary-search

    二进制树形搜索算法

    展开全文
  • RFID-二进制树搜索

    千次阅读 热门讨论 2019-06-16 22:28:22
    MATLAB编程实现二进制树搜索与二分支搜索。

    说明

    MATLAB编程实现二进制树搜索与二分支搜索。

    二进制树搜索

    原理

    二进制搜索技术以唯一的序列号来识别射频电子标签为基础。为了从一簇射频电子标签中选择其中之一, 射频读写器发出一个读命令, 将射频电子标签序列号传输时的数据碰撞引导到射频读写器, 即由射频读写器判断是否有碰撞发生。 如果有, 则进一步搜索。在二进制算法的实现中, 起决定作用的是射频读写器所使用的信号编码必须能够确定碰撞发生的准确位置。
    二进制树搜索算法是由在一个射频读写器和多个射频电子标签之间规定的相互作用(命令和应答)顺序(规则)构成的,目的在于从较大的一组中选出一个标签。算法规定,射频电子标签之间要严格同步,以便准确地监测碰撞位的发生,并且要求能辨认出读写器中数据碰撞的比特位的准确位置,一般采用曼切斯特编码。
    为了实现这种算法,就需要一组命令,这组命令由射频读写器发出,可由射频电子标签处理,命令如下:
    REQUEST:此命令发送一序列号作为参数给射频电子标签。射频电子标签把自己的序列号与接收的序列号比较。如果小于或等于请求序列号,则此射频电子标签回送其序列号给射频读写器。这样就可以缩小预选的射频电子标签的范围请求;
    SELECT:用某个事先确定的序列号作为参数发送给射频电子标签。具有相同序列号的射频电子标签将此作为执行其他命令(例如读出和写入数据)的切入开关, 选择这个射频电子标签。具有其他序列号的射频电子标签只对REQUEST命令应答;
    READ-DATA:选中的射频电子标签将其存储的数据发送给射频读写器;
    UNSELECT:取消一个选中的射频电子标签,使射频电子标签进入“静默”状态, 这种状态中电于标签完全是非撤活的,对收到的REQUEST命令不作应答。为了更新激活射频电子标签,暂时离开射频读写器的作用范围(等于没有供应电压),以实现复位。

    代码

    • request
    %request函数
    %射频电子标签把自己的序列号与接收的序列号比较。如果小于或等于,返回。
    function [bit,D_max]=request(new_label,new_n)
    bit=ones(1,8);           %81
    for k=1:8
        sum=0;
        for j=1:new_n
            sum=sum+new_label(j,k);    
        end
        if sum==0           %即对应位全为0
            bit(1,k)=0;
        elseif sum==new_n   %对应为全为1
            bit(1,k)=1;
        else
            D_max=k;        %碰撞位,且设为0
            bit(1,k)=0;
            break;
        end
    end
    end
    
    • select
    %select函数
    %用某个事先确定的序列号作为参数发送给射频电子标签
    function [new_label2,new_n]=select(new_label,new_bit,new_max,n)
    new_n=0;
    for a=1:n
        if new_label(a,new_max)==new_bit(new_max)
            new_n=new_n+1;
            new_label2(new_n,:)=new_label(a,:);
        else
        end
    end
    end    
    
    • unselect
    %unselect函数
    function [h,nlabel]= unselect(new_label,nlabel,h)
    for nn=1:h
        result = isequal(new_label,nlabel(nn,:));
        if result 
            nlabel(nn,:)=[];  
            h=h-1;
            break;
        end
    end        
    end
    
    • 界面核心代码
    %主要代码位于pushbutton1_Callback
    
    % --- Executes on button press in pushbutton1.
    function pushbutton1_Callback(hObject, eventdata, handles)
    % hObject    handle to pushbutton1 (see GCBO)
    % eventdata  reserved - to be defined in a future version of MATLAB
    % handles    structure with handles and user data (see GUIDATA)
    tic
    tag_count1=get(handles.edit1,'String');  %获取输入的标签总数
    ctag=str2num(tag_count1);              
    rand1=rand(ctag,1)*256;                  %随机生成标签
    rand2=dec2bin(rand1);                       
    tgrand=num2str(rand2);
    rand3=sort(rand1);                       
    rand4=dec2bin(rand3);                  
    rand5=num2str(rand4);
    toc                                      %记录程序运行时间
    set(handles.listbox1,'String',tgrand);   %输出
    set(handles.listbox2,'String',rand5);
    set(handles.edit2,'String',num2str(toc));
    

    界面结果

    在这里插入图片描述

    二分支

    原理

    该方法采用递归的工作方式,遇到碰撞就随机地进行分支,成为多个子集。在接下来的时隙中,主要解决信息包所发生的碰撞。如果再次发生碰撞,就继续随机地分为多个分支。然后依次进行查询,标签被分支后,由于响应的标签数量减少,再次发生碰撞的概率降低,通过不断的分支,减少响应标签的数量,直至分支内没有或仅有一个标签响应。

    1. 先随机生成16位的标签号,定义标签的左右子树;
    2. 先找出标签碰撞的位数,若得到碰撞的位,根据碰撞的位将标签号分为左右两子树(定义左子树位1,右子树位0);
    3. 判断左子树是否只有一个标签或无标签,若是,则该次调用结束,判断上步的右子树是否只有一个标签或无标签,若不是,则进入该右子树的左子树进行查验,以此循环。

    我们定义每一个左右子树都要进行一次查询和一次响应,因为可以计算出操作次数,并定义吞吐量等于标签数目除以总的操作次数。

    代码

    • pick函数
    %定义pick函数:碰撞算法
    function c=pick(A,tag_count,b,len)  %A为标签数组,tag_count为标签数目,b已经使用的时隙数,len为标签长度
    A
    tag_count
    m=1;                                %左子树标签数目
    n=1;                                %右子树标签数目
    b=b+2;                              %查询、响应
    D_max=len;                          %初始化最高碰撞位
    x=0;
    len_l=len;                          %初始化标签长度
    
    if tag_count==1                     %若标签数目为1,直接返回
        c=b;
        return;
    end
    
    for j=1:1:len_l                     %对标签每一位进行判断是否碰撞
        sum=0;
        for k=1:1:tag_count             %所有标签对应为求和
            x=A(k,j);
            sum=sum+x;
        end
        if sum==0                       %即对应为全为0,无碰撞
            ;     
        elseif sum==tag_count           %即对应为全为1,无碰撞
            ;
        else                            %碰撞
            D_max=j;                    %最高碰撞位
            break;
        end
    end
    for i=1:tag_count                   %把标签分成左、右子树
       x=A(i,D_max);
        if x==1                         %左子树为1
            left_tag(m,:)=A(i,:);
            m=m+1;                      %左子树+1
        else
            right_tag(n,:)=A(i,:);
            n=n+1;
        end
    end
    if m==2||m==1                      %左子树有一个标签或无标签则响应完毕
        b=b+2;
        c=b;
    else
        b=pick(left_tag,m-1,b,len);    %如果标签数大于2,则递归调用
    end
    
    if n==2||n==1                      %同上
        b=b+2;
        c=b;   
    else
        b=pick(right_tag,n-1,b,len);
    end
    c=b;                               %返回操作总的次数
    return;
    
    • 主函数核心代码
    %主要代码位于pushbutton1_Callback
    % --- Executes on button press in pushbutton1.
    function pushbutton1_Callback(hObject, eventdata, handles)
    % hObject    handle to pushbutton1 (see GCBO)
    % eventdata  reserved - to be defined in a future version of MATLAB
    % handles    structure with handles and user data (see GUIDATA)
    ctag=str2num(get(handles.edit1,'String'));       %获取输入的标签总数
    ID_length=str2num(get(handles.edit2,'String'));  %获取输入的标签长度
    for i=1:ctag
        tagg(i,:)=randi([0,1],1,ID_length);          %随机生成tagcount个长为ID_length的标签
    end
    tag1 = unique(tagg,'rows');                      %去除重复
    tag_count=size(tag1,1);                          %计算不重复的标签总数
    r = randperm(tag_count);                         %打乱
    tag=tag1(r,:);
    tag;
    sum=0;a=0;
    a=pick(tag,tag_count,0,ID_length)                %调用pick函数
    sum=sum+a;                                       %计算操作次数
    cc=sum;
    tuntu=tag_count/cc;                              %计算吞吐量
    set(handles.edit4,'String',cc);                  %输出操作次数
    set(handles.edit5,'String',tuntu);               %输出吞吐量
    tag = num2str(tag); 
    tag;
    set(handles.listbox2,'String',tag);              %输出待识别的标签
    guidata(hObject,handles);
    
    % --- Executes on button press in pushbutton2.
    function pushbutton2_Callback(hObject, eventdata, handles)
    % hObject    handle to pushbutton2 (see GCBO)
    % eventdata  reserved - to be defined in a future version of MATLAB
    % handles    structure with handles and user data (see GUIDATA)
    close;                                            %关闭窗口
    
    

    结果界面

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 讲解RFID二进制树和ALOHA防碰撞算法的基本原理
  • 物联12:二进制树型搜索算法

    万次阅读 2015-04-15 10:43:49
    二进制防碰撞算法基于轮询的办法,按照二进制树模型和一定的顺序对所有的可能进行遍历,因此它不是基于概率的箅法,而是一种确定性的防碰撞算法,但该算法要将所有可能全部遍历,因此其应用起来比较慢。  二进制...
  • RFID防碰撞 二进制树搜索算法 C语言实现

    千次阅读 热门讨论 2018-04-01 20:31:13
    本篇文章只是简单的用C语言模拟出了二进制搜索算法的实现方法,但是并没有用到理论中的二叉树排序理论,所以并不是一个严格意义上的搜索算法 话不多说,先上一段A标签收到读写器发送的REQUEST命令的程序 if(a...
  • (1)普通二进制树搜索: 设计一个1、11、21…标签数目 ①先设计一个GUI界面,得到8位二进制数的随机序列,分成256份。 ②先对每一次都找出碰撞的最高位; ③选择比碰撞位小的二进制数,然后继续进行第②步骤,直至...
  • 在RFID防碰撞算法中,二进制树算法是目前应用最广泛的一种。因为在算法执行过程中,读写器要多次发送命令给应答器,每次命令都把应答器分成两组,多次分组后最终得到唯一的一个应答器,在这个分组过程中,将对应的...
  • 二进制树型搜索算法的实现步骤如下:  (1)读写器广播发送最大序列号查询条件Q,其作用范围内的标签在同一时刻传输它们的序列号至读写器。  (2)读写器对收到的标签进行响应,如果出现不一致
  •   二制树型搜索算法由读写器控制,基本思想是...二进制树型搜索算法的模型如图所示,其基本思想是将处于冲突的标签分成左 右两个子集0和1,先查询子集0,若没有冲突,则正确识别标签,若仍有冲突 则再分
  • 但是我不会逐步解释算法,而是会深入了解二进制搜索的工作原理和使用方式。 如果您不知道Binary Search,请查看: geeksforgeeks.org/binary-search 。 给定一个已排序的数组,我们找到最中间的元素并使用键...
  • RFID系统二进制数树型搜索算法是如何解决碰撞的?简述其实现步骤。 答:二进制树型搜索算法有读写器控制,基本思想是不断的将导致碰撞的 电子标签进行划分,缩小下一步搜索的标签数量,直到只有一个电子标签进行...
  • 射频识别技术(RFID)是从20世纪80年代走向成熟的一项自动识别技术[1]。...介绍了常用防碰撞算法的原理,并详细分析了二进制搜索算法原理和实现过程,最后对算法的效率进行了研究和比较,得出了改进的建议。
  • 一种二进制树位检测的标签防碰撞算法
  • 二进制搜索防碰撞算法中用的主要命令有: 1、Request(请求):阅读器向其识别区中的标签发送带有标签序列号的请求命令,标签接到命令后,其自身序列号小于或者等于该序列号的标签会将自己的序列号发送给阅读器,...
  • 开博客的第一篇文章便是字典实现模糊匹配,那个时候提到会把字典导入二进制文件后进行搜索 优缺点比较: 对字典的深搜实现模糊匹配: 缺点:每次启动程序需要加载一颗字典,浪费时间,浪费空间。 优点:...
  •  二进制树型搜索算法由读写器控制,基本思想是不断的将导致 碰撞的电子标签进行划分,缩小下一步搜索的标签数量,直到只有 一个电子标签进行回应(即没有碰撞发生)。 二进制树型搜索算法实现步骤为:  【1】...
  • 题目:1000瓶药水,1瓶有毒药,服用后一小时...从0-7的顺序将三位的二进制数按顺序(如图)写出来,写好之后从横向看,三行就分配给三只老鼠,一代表是用这些瓶子的毒药做 了混合,零就是没有用到这些瓶子里的毒药。..
  • 1.算法原理介绍 1.1Xgboost简介 xgboost是Boosting算法的其中一种,Boosting算法的思想是许多弱分类器集成在一起,形成一个强分类器。以为xgboost是一种提升模型,所以他是将许多模型集成在一起,形成一个很强的...
  • 二进制LDPC码的构造及译码算法

    千次阅读 2018-09-09 16:11:04
    构造好的LDPC码校验矩阵和设计性能优异的译码算法是LDPC码研究领域的重点。  常见的LDPC码一般分为两类,一类是随机LDPC码,一般由随机化方法构造;另一类是准循环LDPC码,一般由半随机方 法或者基于代数的结构化...
  • 起初,我是希望寻找一个工具能够对比二进制文件的相似度,通过搜索之后,定位到了ssdeep这个工具,对这个工具进行了实践,能够得到一些相应的结果。但在这个过程中发现了一个博客复现了大致是17/18年左右一篇顶会...
  • 本篇文章翻译自:(State of) The Art of War: Offensive Techniques in Binary Analysis论文下载链接:http://www.cs.ucsb.edu/~chris/research/doc/oakland16_sokbin.pdf文章主要讲解的是常见的二进制分析技术,...
  • Merkle Tree(默克尔算法解析

    万次阅读 多人点赞 2017-01-20 17:52:14
    Merkle Tree,通常也被称作Hash Tree,顾名思义,就是存储hash值的一棵。Merkle的叶子是数据块(例如,文件或者文件的集合)的hash值。非叶节点是其对应子节点串联字符串的hash。[1]1、HashHash是一个把任意长度的...
  • NodeTable类负责以太坊的节点发现,NodeTable采用kademlia(KAD)算法进行节点发现 NodeTable维护一个网络节点列表,此列表为当前可用节点,供上层使用 由于NodeID经过sha3生成出的Hash为256位。列表有256-1=255...
  • Java常用算法原理剖析

    2018-05-17 17:55:58
    用Java实现的所有算法(用于教育)这些只是为了演示的目的。在Java标准库中有许多不同类型的实现,由于性能原因这些要好得多。排序算法气泡从维基百科气泡排序,叫做下沉排序,是一种简单的排序算法,反复遍历要排序的...
  • 分析了RFID系统中二进制搜索算法和动态二进制搜索算法的防碰撞原理,并针对这些算法对...该算法是在二进制树搜索算法的基础上进行改进的.对3种防碰撞算法的性能进行了比较,此防碰撞算法可以提高多卡识别的效率.
  • 随着信息膨胀时代的来临,算法也在不断的精进,相似算法同样在不断的发展,接触过lucene的同学想必都会了解相似夹角的概念,那就是一种相似算法,通过计算两个向量的余弦值来判断两个向量的相似性,但这种方式需...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,448
精华内容 8,179
关键字:

二进制树搜索算法原理