精华内容
下载资源
问答
  • 运放平衡电阻的理解

    2020-08-03 16:07:41
    平衡电阻目的是为了减小运放输入偏置电流在电阻上形成静态输入电压而带来误差详细看书。(减少失调电压)
  • 平衡,字面上的理解是白色的平衡。白平衡是描述显示器中红、绿、蓝三基色 混合生成后白色精确度的一项指标。白平衡是电视摄像领域一个非常重要的概 念,通过它可以解决色彩还原和色调处理的一系列问题
  • 二叉平衡的理解

    2020-06-25 15:54:26
    二叉平衡树就是在二叉搜索树的基础上进行了 优化 二叉平衡树: 空二叉搜索树或者根的左右子树 高度之差绝对值 不超过1;左、右均是 二叉平衡树 ...从最小不平衡的子树的根节点(平衡因子绝对值大于1)到新插入

    二叉平衡树就是在二叉搜索树的基础上进行了 优化

    二叉平衡树: 空二叉搜索树或者根的左右子树 高度之差绝对值 不超过1;左、右均是 二叉平衡树

    二叉树结点的平衡因子:结点的左右子树的高度差

    感觉二叉 平衡树主要内容就在于平衡调整上面

    在我们插入新的元素后可能会导致原来的二叉平衡树不再平衡,此时我们只需从新插入结点到根节点的方向找到最小二叉平衡树 将其调整为 平衡即可。

    可以分为单一型和混合型。

    单一 型:LL或RR

    混合型:LR或RL

    从最小不平衡的子树的根节点(平衡因子绝对值大于1)到新插入节点方向,将路过的三个结点依次记为s,r,u

    上面比如LL的意思:新元素插在了s的左孩子的左子树上。

    根据 单一型或者混合型 可以分为两种 调整方式,单旋转和双旋转。单一型的用 单旋转,混合型的 用双旋转。

    单旋转:s,r,u中,r篡位成为r原先的父节点

    双旋转:s,r,u中,u篡位成为u原先的父节点

    下面是三个例子:

    展开全文
  • 平衡二叉树理解

    2017-11-13 18:36:23
    2016-08-04 09:39 377人阅读 评论(0) 收藏 举报  分类: 算法(12)  ...平衡二叉树(Balanced Binary Tree)是二叉查找树一个进化体,也是第一个引入平衡概念二叉树。1962年,G.M
     分类:算法
    转载:http://www.cppblog.com/cxiaojia/archive/2012/08/20/187776.html
    平衡二叉树(Balanced Binary Tree)是二叉查找树的一个进化体,也是第一个引入平衡概念的二叉树。1962年,G.M. Adelson-Velsky 和 E.M. Landis发明了这棵树,所以它又叫AVL树。平衡二叉树要求对于每一个节点来说,它的左右子树的高度之差不能超过1,如果插入或者删除一个节点使得高度之差大于1,就要进行节点之间的旋转,将二叉树重新维持在一个平衡状态。这个方案很好的解决了二叉查找树退化成链表的问题,把插入,查找,删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间,不过相对二叉查找树来说,时间上稳定了很多


    平衡二叉树实现的大部分过程和二叉查找树是一样的(学平衡二叉树之前一定要会二叉查找树),区别就在于插入和删除之后要写一个旋转算法去维持平衡,维持平衡需要借助一个节点高度的属性。我参考了机械工业出版社的《数据结构与算法分析-C语言描述》写了一个C++版的代码。这本书的AVLTree讲的很好,不过没有很完整的去描述。我会一步一步的讲解如何写平衡二叉树,重点是平衡二叉树的核心部分,也就是旋转算法。

    第一步:节点信息

      相对于二叉查找树的节点来说,我们需要用一个属性二叉树的高度,目的是维护插入和删除过程中的旋转算法。

    代码如下:

    [html] view plain copy
    1. //AVL树节点信息  
    2. template<class T>  
    3. class TreeNode  
    4. {  
    5.     public:  
    6.         TreeNode():lson(NULL),rson(NULL),freq(1),hgt(0){}  
    7.         T data;//值  
    8.         int hgt;//以此节点为根的树的高度  
    9.         unsigned int freq;//频率  
    10.         TreeNode* lson;//指向左儿子的地址  
    11.         TreeNode* rson;//指向右儿子的地址  
    12. };  

    第二步:平衡二叉树类的声明

      声明中的旋转函数将在后边的步骤中详解。

    代码如下:

    [html] view plain copy
    1. //AVL树类的属性和方法声明  
    2. template<class T>  
    3. class AVLTree  
    4. {  
    5.     private:  
    6.         TreeNode<T>* root;//根节点  
    7.         void insertpri(TreeNode<T>* &node,T x);//插入  
    8.         TreeNode<T>* findpri(TreeNode<T>* node,T x);//查找  
    9.         void insubtree(TreeNode<T>* node);//中序遍历  
    10.         void Deletepri(TreeNode<T>* &node,T x);//删除  
    11.         int height(TreeNode<T>* node);//求树的高度  
    12.         void SingRotateLeft(TreeNode<T>* &k2);//左左情况下的旋转  
    13.         void SingRotateRight(TreeNode<T>* &k2);//右右情况下的旋转  
    14.         void DoubleRotateLR(TreeNode<T>* &k3);//左右情况下的旋转  
    15.         void DoubleRotateRL(TreeNode<T>* &k3);//右左情况下的旋转  
    16.         int Max(int cmpa,int cmpb);//求最大值  
    17.   
    18.     public:  
    19.         AVLTree():root(NULL){}  
    20.         void insert(T x);//插入接口  
    21.         TreeNode<T>* find(T x);//查找接口  
    22.         void Delete(T x);//删除接口  
    23.         void traversal();//遍历接口  
    24.   
    25. };  

    第三步:两个辅助方法

      旋转算法需要借助于两个功能的辅助,一个是求树的高度,一个是求两个高度的最大值。这里规定,一棵空树的高度为-1,只有一个根节点的树的高度为0,以后每多一层高度加1。为了解决指针NULL这种情况,写了一个求高度的函数,这个函数还是很有必要的。

    代码如下:

    [html] view plain copy
    1. //计算以节点为根的树的高度  
    2. template<class T>  
    3. int AVLTree<T>::height(TreeNode<T>* node)  
    4. {  
    5.     if(node!=NULL)  
    6.         return node->hgt;  
    7.     return -1;  
    8. }  
    9. //求最大值  
    10. template<class T>  
    11. int AVLTree<T>::Max(int cmpa,int cmpb)  
    12. {  
    13.     return cmpa>cmpb?cmpa:cmpb;  
    14. }  

    第四步:旋转

      对于一个平衡的节点,由于任意节点最多有两个儿子,因此高度不平衡时,此节点的两颗子树的高度差2.容易看出,这种不平衡出现在下面四种情况:


         1、6节点的左子树3节点高度比右子树7节点大2,左子树3节点的左子树1节点高度大于右子树4节点,这种情况成为左左

      2、6节点的左子树2节点高度比右子树7节点大2,左子树2节点的左子树1节点高度小于右子树4节点,这种情况成为左右

      3、2节点的左子树1节点高度比右子树5节点小2,右子树5节点的左子树3节点高度大于右子树6节点,这种情况成为右左

      4、2节点的左子树1节点高度比右子树4节点小2,右子树4节点的左子树3节点高度小于右子树6节点,这种情况成为右右

      从图2中可以可以看出,1和4两种情况是对称的,这两种情况的旋转算法是一致的,只需要经过一次旋转就可以达到目标,我们称之为单旋转。2和3两种情况也是对称的,这两种情况的旋转算法也是一致的,需要进行两次旋转,我们称之为双旋转。

    第五步:单旋转

      单旋转是针对于左左和右右这两种情况的解决方案,这两种情况是对称的,只要解决了左左这种情况,右右就很好办了。图3是左左情况的解决方案,节点k2不满足平衡特性,因为它的左子树k1比右子树Z深2层,而且k1子树中,更深的一层的是k1的左子树X子树,所以属于左左情况。



    为使树恢复平衡,我们把k2变成这棵树的根节点,因为k2大于k1,把k2置于k1的右子树上,而原本在k1右子树的Y大于k1,小于k2,就把Y置于k2的左子树上,这样既满足了二叉查找树的性质,又满足了平衡二叉树的性质。

      这样的操作只需要一部分指针改变,结果我们得到另外一颗二叉查找树,它是一棵AVL树,因为X向上一移动了一层,Y还停留在原来的层面上,Z向下移动了一层。整棵树的新高度和之前没有在左子树上插入的高度相同,插入操作使得X高度长高了。因此,由于这颗子树高度没有变化,所以通往根节点的路径就不需要继续旋转了。

    代码如下:

    [html] view plain copy
    1. //左左情况下的旋转  
    2. template<class T>  
    3. void AVLTree<T>::SingRotateLeft(TreeNode<T>* &k2)  
    4. {  
    5.     TreeNode<T>* k1;  
    6.     k1=k2->lson;  
    7.     k2->lson=k1->rson;  
    8.     k1->rson=k2;  
    9.   
    10.     k2->hgt=Max(height(k2->lson),height(k2->rson))+1;  
    11.     k1->hgt=Max(height(k1->lson),k2->hgt)+1;  
    12. }  
    13. //右右情况下的旋转  
    14. template<class T>  
    15. void AVLTree<T>::SingRotateRight(TreeNode<T>* &k2)  
    16. {  
    17.     TreeNode<T>* k1;  
    18.     k1=k2->rson;  
    19.     k2->rson=k1->lson;  
    20.     k1->lson=k2;  
    21.   
    22.     k2->hgt=Max(height(k2->lson),height(k2->rson))+1;  
    23.     k1->hgt=Max(height(k1->rson),k2->hgt)+1;  
    24. }  

    第六步:双旋转

    对于左右和右左这两种情况,单旋转不能使它达到一个平衡状态,要经过两次旋转。双旋转是针对于这两种情况的解决方案,同样的,这样两种情况也是对称的,只要解决了左右这种情况,右左就很好办了。图4是左右情况的解决方案,节点k3不满足平衡特性,因为它的左子树k1比右子树Z深2层,而且k1子树中,更深的一层的是k1的右子树k2子树,所以属于左右情况。


    为使树恢复平衡,我们需要进行两步,第一步,把k1作为根,进行一次右右旋转,旋转之后就变成了左左情况,所以第二步再进行一次左左旋转,最后得到了一棵以k2为根的平衡二叉树树。

    代码如下:

    [html] view plain copy
    1. //左右情况的旋转  
    2. template<class T>  
    3. void AVLTree<T>::DoubleRotateLR(TreeNode<T>* &k3)  
    4. {  
    5.     SingRotateRight(k3->lson);  
    6.     SingRotateLeft(k3);  
    7. }  
    8. //右左情况的旋转  
    9. template<class T>  
    10. void AVLTree<T>::DoubleRotateRL(TreeNode<T>* &k3)  
    11. {  
    12.     SingRotateLeft(k3->rson);  
    13.     SingRotateRight(k3);  
    14. }  

     第七步:插入

      插入的方法和二叉查找树基本一样,区别是,插入完成后需要从插入的节点开始维护一个到根节点的路径,每经过一个节点都要维持树的平衡。维持树的平衡要根据高度差的特点选择不同的旋转算法。

    代码如下:

    [html] view plain copy
    1. /插入  
    2. template<class T>  
    3. void AVLTree<T>::insertpri(TreeNode<T>* &node,T x)  
    4. {  
    5.     if(node==NULL)//如果节点为空,就在此节点处加入x信息  
    6.     {  
    7.         node=new TreeNode<T>();  
    8.         node->data=x;  
    9.         return;  
    10.     }  
    11.     if(node->data>x)//如果x小于节点的值,就继续在节点的左子树中插入x  
    12.     {  
    13.         insertpri(node->lson,x);  
    14.         if(2==height(node->lson)-height(node->rson))  
    15.             if(x<node->lson->data)  
    16.                 SingRotateLeft(node);  
    17.             else  
    18.                 DoubleRotateLR(node);  
    19.     }  
    20.     else if(node->data<x)//如果x大于节点的值,就继续在节点的右子树中插入x  
    21.     {  
    22.         insertpri(node->rson,x);  
    23.         if(2==height(node->rson)-height(node->lson))//如果高度之差为2的话就失去了平衡,需要旋转  
    24.             if(x>node->rson->data)  
    25.                 SingRotateRight(node);  
    26.             else  
    27.                 DoubleRotateRL(node);  
    28.     }  
    29.     else ++(node->freq);//如果相等,就把频率加1  
    30.     node->hgt=Max(height(node->lson),height(node->rson));  
    31. }  
    32. //插入接口  
    33. template<class T>  
    34. void AVLTree<T>::insert(T x)  
    35. {  
    36.     insertpri(root,x);  
    37. }  

    第八步:查找

    和二叉查找树相比,查找方法没有变法,不过根据存储的特性,AVL树能维持在一个O(logN)的稳定的时间,而二叉查找树则相当不稳定。

    代码如下:

    [html] view plain copy
    1. //查找  
    2. template<class T>  
    3. TreeNode<T>* AVLTree<T>::findpri(TreeNode<T>* node,T x)  
    4. {  
    5.     if(node==NULL)//如果节点为空说明没找到,返回NULL  
    6.     {  
    7.         return NULL;  
    8.     }  
    9.     if(node->data>x)//如果x小于节点的值,就继续在节点的左子树中查找x  
    10.     {  
    11.         return findpri(node->lson,x);  
    12.     }  
    13.     else if(node->data<x)//如果x大于节点的值,就继续在节点的左子树中查找x  
    14.     {  
    15.         return findpri(node->rson,x);  
    16.     }  
    17.     else return node;//如果相等,就找到了此节点  
    18. }  
    19. //查找接口  
    20. template<class T>  
    21. TreeNode<T>* AVLTree<T>::find(T x)  
    22. {  
    23.     return findpri(root,x);  
    24. }  

    第九步:删除

      删除的方法也和二叉查找树的一致,区别是,删除完成后,需要从删除节点的父亲开始向上维护树的平衡一直到根节点。

    代码如下:

    [html] view plain copy
    1. //删除  
    2. template<class T>  
    3. void AVLTree<T>::Deletepri(TreeNode<T>* &node,T x)  
    4. {  
    5.     if(node==NULL) return ;//没有找到值是x的节点  
    6.     if(x < node->data)  
    7.     {  
    8.          Deletepri(node->lson,x);//如果x小于节点的值,就继续在节点的左子树中删除x  
    9.          if(2==height(node->rson)-height(node->lson))  
    10.             if(node->rson->lson!=NULL&&(height(node->rson->lson)>height(node->rson->rson)) )  
    11.                 DoubleRotateRL(node);  
    12.             else  
    13.                 SingRotateRight(node);  
    14.     }  
    15.   
    16.     else if(x > node->data)  
    17.     {  
    18.          Deletepri(node->rson,x);//如果x大于节点的值,就继续在节点的右子树中删除x  
    19.          if(2==height(node->lson)-height(node->rson))  
    20.             if(node->lson->rson!=NULL&& (height(node->lson->rson)>height(node->lson->lson) ))  
    21.                 DoubleRotateLR(node);  
    22.             else  
    23.                 SingRotateLeft(node);  
    24.     }  
    25.   
    26.     else//如果相等,此节点就是要删除的节点  
    27.     {  
    28.         if(node->lson&&node->rson)//此节点有两个儿子  
    29.         {  
    30.             TreeNode<T>temp=node->rson;//temp指向节点的右儿子  
    31.             while(temp->lson!=NULL) temp=temp->lson;//找到右子树中值最小的节点  
    32.             //把右子树中最小节点的值赋值给本节点  
    33.             node->data=temp->data;  
    34.             node->freq=temp->freq;  
    35.             Deletepri(node->rson,temp->data);//删除右子树中最小值的节点  
    36.             if(2==height(node->lson)-height(node->rson))  
    37.             {  
    38.                 if(node->lson->rson!=NULL&& (height(node->lson->rson)>height(node->lson->lson) ))  
    39.                     DoubleRotateLR(node);  
    40.                 else  
    41.                     SingRotateLeft(node);  
    42.             }  
    43.         }  
    44.         else//此节点有1个或0个儿子  
    45.         {  
    46.             TreeNode<T>temp=node;  
    47.             if(node->lson==NULL)//有右儿子或者没有儿子  
    48.             node=node->rson;  
    49.             else if(node->rson==NULL)//有左儿子  
    50.             node=node->lson;  
    51.             delete(temp);  
    52.             temp=NULL;  
    53.         }  
    54.     }  
    55.     if(node==NULL) return;  
    56.     node->hgt=Max(height(node->lson),height(node->rson))+1;  
    57.     return;  
    58. }  
    59. //删除接口  
    60. template<class T>  
    61. void AVLTree<T>::Delete(T x)  
    62. {  
    63.     Deletepri(root,x);  
    64. }  

    第十步:中序遍历

    代码如下:

    [html] view plain copy
    1. //中序遍历函数  
    2. template<class T>  
    3. void AVLTree<T>::insubtree(TreeNode<T>* node)  
    4. {  
    5.     if(node==NULL) return;  
    6.     insubtree(node->lson);//先遍历左子树  
    7.     cout<<node->data<<" ";//输出根节点  
    8.     insubtree(node->rson);//再遍历右子树  
    9. }  
    10. //中序遍历接口  
    11. template<class T>  
    12. void AVLTree<T>::traversal()  
    13. {  
    14.     insubtree(root);  
    15. }  


    第十一步:关于效率

      此数据结构插入、查找和删除的时间复杂度均为O(logN),但是插入和删除需要额外的旋转算法需要的时间,有时旋转过多也会影响效率。

      关于递归和非递归。我用的是递归的方法进行插入,查找和删除,而非递归的方法一般来说要比递归的方法快很多,但是我感觉非递归的方法写出来会比较困难,所以我还是选择了递归的方法。

      还有一种效率的问题是关于高度信息的存储,由于我们需要的仅仅是高度的差,不需要知道这棵树的高度,所以只需要使用两个二进制位就可以表示这个差。这样可以避免平衡因子的重复计算,可以稍微的加快一些速度,不过代码也丧失了相对简明性和清晰度。如果采用递归写法的话,这种微加速就更显得微乎其微了。

     

    展开全文
  • 平衡的理解笔记

    2016-03-03 10:00:22
    最近在理解平衡概念时,想先自己手动设计,设想 如果是我话,我会怎么解决这个问题。在设计过程中,发现一定要懂得利用 数学归纳法 思想,这一点很重要,相当于给问题赋予了已知条件,可以简化问题,将...

    最近在理解平衡树的概念时,想先自己手动设计,设想 如果是我的话,我会怎么解决这个问题。在设计的过程中,发现一定要懂得利用 数学归纳法 的思想,这一点很重要,相当于给问题赋予了已知条件,可以简化问题,将问题简单化。 其实以前做ACM题思考算法的过程都用了这个思想,发现有时候会忘了利用这个思想,然后就没了一些好条件,浪费了一大把时间。这一次思考平衡树的过程也忘了这个思想,导致浪费了时间。。。 

    看代码是弄懂一个算法的一个很有帮助的途径。


    举个例子说明其实就是,你想自己设计一个方法来保持二叉树的性质,那么你可以一个节点一个节点的进行二叉树的节点增加操作,然后利用归纳法的思想,一开始你的二叉树都是保有良好性质的二叉树,即好二叉树,而在某一步时,出现了坏二叉树,这时候可以先想如何把这个坏二叉树变成好二叉树,

    问题得到了简化,因为,这个坏二叉树=好二叉树+1个节点,这个条件非常重要!!!



    二叉搜索树可能出现失衡的清醒。构造二叉树需要尽量平均分配,而失衡其实意思就是分配不平均,左右子树高度相差太大,那什么是高度相差太大,很容易可以感受就是高度相差2或者2以上。  而平衡二叉树就是为了平衡,使高差差尽量小


    然后就是理解 旋转 的概念。 首先,旋转是一种针对二叉树的操作,是为了解决二叉树失衡的一种操作。

    那么怎么弄懂旋转,

    一种方法是直接查资料,然后根据网上的图示,弄懂旋转具体是怎么操作的,然后弄明白旋转为什么可以平衡二叉树。

    另一种方法就是自己去构造二叉树,一旦出现不平衡情况,你会怎么解决,然后去画草稿自己解决,然后你可以设计各种各样的方法,有些方法会被你否决,而有些方法会被采纳,  然后再去查阅资料,你会发现,旋转操作其实已经被你想到了,只是当时你不知道这个操作叫旋转,或者说这个操作被大多数人定义为 旋转。


    treap树堆,就是给节点加了优先级,同理,你可以先自己想想,如果是你的话,你会怎么设计节点增加与删除操作。


    弄明白了treap树堆的节点插入操作,可以发现,节点删除操作其实就是节点插入操作的逆过程。


    treap树堆已经理解好了,现在正在想AVL树,已经弄懂AVL树的节点添加操作,即各种旋转操作,现在正在思考节点删除操作。已经弄懂AVL树的节点删除操作。


    其实AVL树的对高度差超过2的子树中比较高的子树进行向下划分,使得最后得到的4个子树之间高度保持1的差距。得到4个子树后进行再分配,旋转操作就是为了再分配。



    展开全文
  • 101平衡模式 DIR的理解

    千次阅读 2017-07-29 12:05:45
    但是在点对点和多点对点网络结构中,非平衡方式传输没有充分发挥这种网络内在潜力。  2.平衡方式传输:主站和子站可以同时启动链路传输服务,所以必须有一对全双工通道。  这里规定对于点对点和多点对

    101平衡模式

    传输方式分为非平衡方式和平衡方式传输两种: 

    1.非平衡方式传输:只有主站启动各种链路传输服务,子站只有当主站请求时才传输。这种传输方式对于所有网络结构都可适用。但是在点对点和多点对点的网络结构中,非平衡方式传输没有充分发挥这种网络的内在潜力。 

    2.平衡方式传输:主站和子站可以同时启动链路传输服务,所以必须有一对全双工的通道。 

    这里规定对于点对点和多点对点的网络结构采用平衡方式传输,对于多点共线、多点环形和多点星形的网络结构采用非平衡方式传输。 

     

    非平衡是表示通讯双方一主一从关系(一个询问,一个应答),报文发送方向通过PRM识别;平衡是表示双方没有主从关系,是对等关系,报文发送方向通过PRM识别,双方都可以发起询问(命令),也能应答对方发起方报文PRM=1,响应方报文PRM=0,大多情况下用的都是非平衡传输规则,平衡传输规则很少见。

     

    在非平衡模式中PRM决定了报文传送的方向,PRM=1表示主站向子站传输报文,PRM=0表示子站向主站传输报文;

    DIR=1表示由子站发出的上行报文,DIR=0表示主站下发的下行报文;

    在两个等同的站(即两个控制中心)由协商确定DIR位的定义。

    像之前的介绍一样平衡模式是表示双方没有主从关系,是对等关系,也就是说在传输过程中主站可以主动发送数据,从站也可以主动发起数据,但是主从站的关系是设备在使用时就确定好的,比如说我们现在要做的是一个馈线终端的101规约,那么这个设备肯定是作为从站来使用,协议自然是从站的编写方式,在回复主站时DIR=1(两个控制中心的DIR是由协商决定的);而PRM是决定发送的方向,不管主站或者从站PRM的值都可以是1,这里的“1”表示报文数据是从哪里启动的。

     

    报文功能码的解析需要根据两种模式下的方式进行解析。

    平衡模式的控制域与非平衡模式的控制域的功能码是有区别的,如下图:

     

     

        启动方向的功能码和服务                   从动方向所允许的功能码和服务

    <0> 复位远方链路                         <0>确认: 认可或者

                                                  <1>确认: 否定认卟

      <1>   复位用户进程                          <0>确认: 认可或者

                                                  <1>确认: 否定认可

      <3>   发送/确认 链路测试功能                <0>确认: 认可或者

                                                  <1>确认: 否定认可

      <4>   发送/无回答                           无回答

    <9>   请求/响应 请求链路状态               <11>响应: 链路状态

    图1平衡模式

     

    启动方向的功能码和服务   

    从动方向所允许的功能码和服务 

             <0>   复位远方链路

    <0>确认: 认可或者

    <1>确认: 否定认可

             <1>   复位用户进程

    <0>确认: 认可或者

    <1>确认: 否定认可

             <3>   发送/确认用户数据

    <0>确认: 认可或者

    <1>确认: 否定认可

             <4>   发送/无回答

    无回答

             <8>   请求访问要求

    <11>响应: 链路状态 

             <9>   请求/响应 请求链路状态

    <11>响应: 链路状态

            <10>   请求/响应

             请求1级用户数据

              <8>响应: 用户数据或者

            <9>响应: 无所请求的用户数据

    <11> 请求/响应         

             请求2级用户数据

     <8>响应: 用户数据或者

            <9>响应: 无所请求的用户数据

    图2 非平衡模式

     

    平衡模式下的报文实例:

     

    18-14:54:27.954 send:10 49 01 00 4a 16  //49 0100 9 请求链路状态

    18-14:54:28.924 recv:10 8b 01 00 8c 16  //8b 1000 b 响应链路状态

    18-14:54:29.167 send:10 40 01 00 41 16  //40 0100 0 复位链路

    18-14:54:30.138 recv:10 80 01 00 81 16  //80 1000 0 确认

    18-14:54:30.218 recv:10 c9 01 00 ca 16  //c9 1100 9 请求链路

    18-14:54:30.380 send:10 0b 01 00 0c 16  //0b 0000 b 响应链路状态

    68 0b 0b 68 73 01 00 64 01 06 01 00 00 00 14 f4 16 //73 0111 3 发送数据 总召唤 

    18-14:54:31.514 recv:10 c0 01 00 c1 16  //c0 1100 0 确认(响应链路状态)

    10 80 01 00 81 16  //80 1000 0 确认(总召唤)

    18-14:54:31.675 send:10 00 01 00 01 16  //00 0000 0 确认

    18-14:54:32.727 recv:

    68 0b 0b 68 f3 01 00 46 01 04 01 00 00 00 00 40 16  //f3 1111 3 发送数据 70 响应总召唤

    18-14:54:32.889 send:10 00 01 00 01 16  //00 0000 0 确认

    18-14:54:33.940 recv:

    68 0b 0b 68 d3 01 00 64 01 07 01  //d3 1101 3 发送数据 

    18-14:54:34.021 recv:00 00 00 14 55 16  //

    18-14:54:34.102 send:10 00 01 00 01 16  //00 0000 0 确认

    展开全文
  • 若要理解平衡二叉树(AVL),先要理解二叉排序树,很好理解,二叉排序树有这样特点:若左子树不为空,则左子树上所有节点值均小于它根节点值;若右子树不为空,则右子树所有节点值均大于根节点值,...
  • 是一颗二叉查找树 (对于任意节点x, 其左子树所有节点都小于x, x右子树节点都大 于等于x) 是一颗平衡树, 平衡意思是对于任意节点, 其左子树高度和右子树高度相差不超过1, 左右 子树高度差称为平衡因子 a, 也...
  • 而为了让时间复杂度仍然保持O(logn)级别,所以加上了平衡的要求,这样的查找二叉树被称为平衡二叉树,英文缩写为AVL树; 二、平衡二叉树的数据结构: 平衡二叉树附加了一个平衡因子,用于衡量...
  • 它是一种高度平衡的二叉排序树。高度平衡?意思是说,要么它是一棵空树,要么它的左子树和右子树都是平衡二叉树,且左子树和右子树的深度之差的绝对值不超过1。  将二叉树上结点的左子树深度减去右子树深度的值...
  • 理解平衡

    2017-10-31 11:00:24
    色温概念属于传统摄影基础知识,本节不准备过多解释色温,仅就与数码白平衡有关部分概念稍作讨论。尽管原理相同,但是数码技术对色温应用和控制不完全照搬胶片技法,设定、改变色温操作皆有很大不同。 ...
  • 平衡小车PID理解

    千次阅读 多人点赞 2018-08-13 13:19:32
     先来解释一下让平衡小车原理,设置机械中值为0,平衡小车在不平衡时有偏离机械中值倾角,为了平衡这个倾角必须让小车向那边赶。如何让小车向有倾角那边赶呢?这个时候就需要输出一个准确PWM!这个准确PWM...
  • 平衡理解

    2009-12-06 22:03:00
    数码名词:什么是白平衡调节(多图) http://www.sina.com.cn 2004年07月24日15:46 IT168....对于这一切如果能调整白平衡,则在所得到照片中就能正确地以"白"为基色来还原其他颜色。 一般白平衡有多种模式,...
  • 平衡二叉树旋转理解

    千次阅读 多人点赞 2019-03-12 13:58:54
    给A左子树左边插导致A不平衡 只看BL,B,A,AR4个点,右旋后变成 然后看BR节点,因为BR原来在B右子树,因此B&lt;BR&lt;A,根据这点将BR在补上,比B大因此在B右子树,比A小,因此在A左子树。 2.右...
  • 平衡二叉树(AVL)的理解和实现(Java)

    千次阅读 2019-03-13 20:48:40
    从平衡二叉树的名字中可以看出来,它是一种高度平衡的二叉排序树。那么什么叫做高度平衡呢?意思就是要么它是一颗空树,要么它的左子树和右子树都是平衡二叉树,且左子树和右子树的深度只差的绝对值绝对不超过1。 ...
  • AVL平衡的理解(插入、查找、删除) Dargon 2020/11/21 所遇到的的重要的问题: 教科书 来自:《数据结构和算法分析》第四章 树 AVL平衡树出现的原因 在一般的二叉树的插入和删除操作中,想想出现最坏的...
  • 平衡二叉树,就是指二叉树中每个节点其左右孩子子树高度,不能超过1。 二叉树递归过程理解 二叉树最基本遍历,前中后序遍历,最简单就是用递归实现。 再次看二叉树递归过程,可以看到,其实,每个节点都...
  • 完全理解平衡二叉树

    2019-05-13 12:35:01
    非常感谢小甲鱼讲解与参考下面博客(非常有助于理解程序) https://blog.csdn.net/deeplan_1994/article/details/82387202 平衡二叉排序树(AVL)【self-Balance Binary Search Tree】 定义: 思路:使用递归...
  • 平衡电阻目的是为了减小运放输入偏置电流在电阻上形成静态输入电压而带来误差详细看书。(减少失调电压)当运放输入偏置电流较小,或信号较大,其影响可以忽略时,可以不用平衡电阻。R2=R1//Rf-----------------...
  • 1.平衡二叉树失衡原因以及调整思路? 平衡二叉树失衡原因是由于 插入者破坏,因此插入点为破坏者由于插入者到来,使平衡因子绝对值,即多了一层 调整思路: 找到距离插入者即破坏者最近被破坏者 (1)让...
  • 我们可以看到,一个成功的程序员在开发的时候,他对平衡的理解体现在很多方面,下面是其中的一些:  速度和质量  具的代表性的一个例子是在软件开发过程中,速度和质量之间的平衡。开发软件时,如果只追求速度...
  • 理解平衡查找树

    2020-05-04 21:46:03
    平衡查找树问题2-3查找树 问题 二分查找 对于N个键有序数组进行二分查找,最多需要lgN+1lgN+1lgN+1次比较. 说明:首先要对数组中值进行一次比较 随后每二分一次,就比较一次。比如2要比较2次,4要比较3次,...
  • 平衡二叉树或者是一棵空树,或者满足以下性质:它左子树和右子树高度之差绝对值不超过1,并且左子树和右子树也是一个平衡二叉树。 平衡因子 左子树高度减去右子树高度值或者右子树高度减去左子树高度...
  • 深层理解-栈平衡原理

    2020-07-12 20:21:09
    深层理解-栈平衡原理-底层是如何实现栈平衡的?  在iOS、android操作系统中,经常会遇到入栈出栈的操作。那么现在操作系统已经不需要我们去关心堆栈的操作。 比如:iOS中的ARC模式,android中的JVM都会帮我们自动...
  • 关于平衡二叉树一句代码不是很理解, 程序代码:

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,642
精华内容 1,456
关键字:

平衡的理解