c++的学习之路：26、AVL树

摘要

本章主要是说一下AVL树的实现，这里说的是插入的底层原理

目录

摘要

一、原理

二、四种旋转

1、左单旋

2、右单旋

3、左右双旋

4、右左双旋

三、代码实现

1、节点创建

2、插入

3、旋转

4、判断是否平衡

5、测试

 

四、代码

一、原理

前面说了搜索二叉树和map/multimap/set/multiset进行了简单的介绍，在其文档介绍中发现，这几个容器有个共同点是：其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查
找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii
和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：它的左右子树都是AVL树，左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在O(log_2 n)，搜索时间复杂度O(log_2 n)。

下面的图就是一颗AVL树，画的有点抽象，0、-1、1就是平衡因子

二、四种旋转

1、左单旋

如下图就是左单选的过程，就是b肯定是比30大，这时就可以把b连接到30的右边，然后把60变成根节点，30变成60的左节点，就是如下图这种变化，然后这时就需要进行更新平衡因子，就可以进行左旋了，电脑画图太麻烦了，我就放一下我的手图了。

 

2、右单旋

右单选，与做单选相反就是把右边的进行放在左边，然后原理都差不多，就是b的位置肯定是比60小然后就放到30左边，然后在进行旋转进行连接在，这样就可以右旋了，这里我就不画电脑的图了，用我的手图代替了

3、左右双旋

左右双旋就是先进行做单选在进行右单选，这种情况的形状就是<就是这种的就是一个小于号，当直接左旋或者右旋就会把树给扭曲了，就不是平衡了们就是先把他变成/这种形状然后在进行右单选就可以平衡这个二叉树了，下面就是我画的图了，就不用电脑画了。

4、右左双旋

这里就是和上面那个双旋相反，就是先把>这个形状变成\这种，然后就是先进行右单选，在进行做单选，就可以把这颗树进行平衡了，这里就不进行画图了，因为原理都差不多。

三、代码实现

1、节点创建

这个节点是利用三叉链进行维护的，数据存储也就是和搜索二叉树的原理，因为搜索二叉树会右歪脖子树，所以这里就只是平衡，但是他的原理还是差不多，所以这里也是利用键值对进行一个pair容器的创建，然后在创建一个bf进行充当平衡因子进行维护。

template<class K,class V>
struct AVLtreeNode//三叉链
{
    AVLtreeNode<K, V>* _left;//左孩子
    AVLtreeNode<K, V>* _right;//右孩子
    AVLtreeNode<K, V>* _parent;//父母节点
    pair<K, V> _kv;//键值对，用来存储数据
    int _bf;//平衡因子，用来平衡AVL树，使他相对像完全二叉树
    AVLtreeNode(const pair<K, V>& kv)
        :_left(nullptr)
        , _right(nullptr)
        , _parent(nullptr)
        , _kv(kv)
        , _bf(0)
    {}
};

2、插入

插入的代码就是和搜索二叉树原理差不多，也就是大于在右边小于在左边，这里创建也是先进行插入，没有节点的时候就插入在根，有的时候就去遍历寻找，大的在右边小的在左边，然后进行插入，在进行更新平衡因子，这里是利用一个节点记录当前的父节点时候，就可以进行循环进行更新平衡因子，等于2或者-2的时候就需要进行旋转了，这时有四种情况

1、父节点=2、当前节点=1就是进行左单旋

2、父节点=-2、当前节点=-1就是右单旋

3、父节点=2、当前节点=-1时，就是双旋了，左右双旋

4、父节点=-1、当前节点=1时，就是右左双旋

下方代码就是我写的插入，也有注释

bool Insert(const pair<K, V>& kv)
    {
        if (_root == nullptr)//如果是空节点直接申请，然后返回true
        {
            _root = new Node(kv);
            return true;
        }
        Node* parent = nullptr;//记录父节点
        Node* cur = _root;//记录当前节点
        while (cur)//遍历去寻找插入的地方
        {
            if (cur->_kv.first < kv.first)//大于就去左边寻找
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_kv.first > kv.first)//大于就去右边寻找
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return false;//找不到就返回false
            }
        }
        cur = new Node(kv);//创建新的节点
        if (parent->_kv.first > kv.first)//如果小于就插入在右边
        {
            parent->_left = cur;
        }
        else if (parent->_kv.first < kv.first)//如果大于就插入到左边
        {
            parent->_right = cur;
        }
        cur->_parent = parent;//记录一下父节点的地址
        while (parent)//平衡因子的更新，持续到根
        {
            if (cur == parent->_right)//判断新的节点在父节点的左右，如果在右边平衡因子就++，如果在左边就--
            {
                parent->_bf++;
            }
            else
            {
                parent->_bf--;
            }
            if (parent->_bf == 1 || parent->_bf == -1)//如果父节点的平衡因子等于1或者-1，接着更新
            {
                parent = parent->_parent;
                cur = cur->_parent;
            }
            else if(parent->_bf==0)//如果平衡因子等于0就退出
            {
                break;
            }
            else if (parent->_bf == 2 || parent->_bf == -2)//超长了，准备旋转了，有四种情况
            {
                if (parent->_bf == 2 && cur->_bf == 1)//当父节点的平衡因子等于2当前节点的平衡因子等于1时                
                {                                      //就是相当于右边是一条直线时，然后进行左旋
                    RotateL(parent);//调用左旋函数
                }
                else if (parent->_bf == -2 && cur->_bf == -1)//当父平衡因子等于-2当前节点平衡因子等于-1时
                {                                                //就是左边时一条直线的情况时，然后进行右旋
                    RotateR(parent);//调用右旋函数
                }
                else if (parent->_bf == -2 && cur->_bf == 1)//当父节点平衡因子等于-2时，当前节点的平衡因子等于-1时
                {                                            //就是相当于一条折现，就是<这个形状，需要旋转两次，先左旋在右旋
                    RotateLR(parent);//调用先左旋在右旋的函数
                }
                else if (parent -> _bf == 2 && cur->_bf == -1)//当父节点平衡因子等于2时，当前节点平衡因子等于-1时
                {                                            //就是相当于>这个形状，也是需要旋转两次，先进性右旋在进行左旋
                    RotateRL(parent);//调用先右旋在左旋的函数
                }
                else
                {
                    assert(false);//上述情况都没出现，就说明树已经出现问题了，这里直接利用断言直接报错，断死
                }
                break;
            }
            else
            {
                assert(false);//这里就是更新平衡因子失败，也就是说上述都没，也就是直接报错，因为树也是出现错误了
            }
        }
    return true;
    }

3、旋转

下面这段代码就是四种旋转，在左右单旋后，更新平衡因子是0，双旋的平衡因子需要根据具体条件具体实现，具体怎么是先把的下面都有注释。

void RotateL(Node* parent)//左旋
    {
        Node* subR = parent->_right;//记录父节点的右侧，用来后续旋转
        Node* subRL = subR->_left;//记录subR的左侧，这个节点比父节点大，比subR小
        parent->_right = subRL;//因为这个节点比父节点大，所以连接父节点在右边
        if (subRL)
            subRL->_parent = parent;//如果subRL节点不是空姐点就把他的父节点置为父节点
        Node* ppnode = parent->_parent;//记录父节点的父节点
        subR->_left = parent;//旋转把subR的左节点连接为父节点，因为父节点比subR节点小
        parent->_parent = subR;//把父节点的父节点置为subR
        if (ppnode == nullptr)//判断ppnode是否为空也就是之前的父节点是否为根
        {
            _root = subR;//如果是根的话，就把subR置为根，在把subR的父节点置为空
            _root->_parent = nullptr;
        }
        else
        {
            if (ppnode->_left == parent)//判断ppnode的左节点是否为之前的父节点，如果是就把位置换成subR
            {
                ppnode->_left = subR;
            }
            else
            {
                ppnode->_right = subR;//判断ppnode的右节点是否为之前的父节点，如果是就把位置换成subR
            }

            subR->_parent = ppnode;//在进行连接subR的父节点
        }
        parent->_bf = subR->_bf = 0;//最后更新平衡因子，因为旋转过后肯定是平衡的所以直接置为0
    }

    void RotateR(Node* parent)//右旋，与上面左旋的原理差不多，就是换个方向
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        parent->_left = subLR;
        if (subLR)
            subLR->_parent = parent;
        Node* ppnode = parent->_parent;
        subL->_right = parent;
        parent->_parent = subL;
        if (parent == _root)
        {
            _root = subL;
            _root->_parent = nullptr;
        }
        else
        {
            if (ppnode->_left == parent)
            {
                ppnode->_left = subL;
            }
            else
            {
                ppnode->_right = subL;
            }
            subL->_parent = ppnode;
        }
        subL->_bf = parent->_bf = 0;
    }

    void RotateLR(Node* parent)//双旋之先左旋在右旋
    {
        Node* subL = parent->_left;//记录父节点的左侧
        Node* subLR = subL->_right;//记录subL的右侧因为形状是<这样的，然后需要先左旋进行掰直
        int bf = subLR->_bf;//用于记录平衡因子
        RotateL(parent->_left);//利用左旋函数进行左旋，这里就是把父节点的左侧当成父节点传进去，也就是subL
        RotateR(parent);//然后在进行右旋
        if (bf == 1)//更新平衡因子，当前平衡因子如果等于1就把父节点的平衡因子置为0，subLR的为0，因为这个节点在旋转过后
        {            //就会平衡，但是在bf等于1时，左边肯定是有的，所以subL就是-1
            parent->_bf = 0;
            subLR->_bf = 0;
            subL->_bf = -1;
        }
        else if (bf == -1) //在旋转之前平衡因子是-1 的话，在旋转结束时，也就是说明父节点的位置就是需要置为1，因为之前
        {                    //在左，旋转之后就是有右，其他两个就是0
            parent->_bf = 1;
            subLR->_bf = 0;
            subL->_bf = 0;
        }
        else if (bf == 0)//如果都是0的话旋转后也是0就直接更新成0
        {
            parent->_bf = 0;
            subLR->_bf = 0;
            subL->_bf = 0;
        }
        else//如果没有就说明树出现问题了直接断言报错
        {
            assert(false);
        }
    }

    void RotateRL(Node* parent)//现右旋在左旋与上面差不多
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        int bf = subRL->_bf;
        RotateR(parent->_right);
        RotateL(parent);
        if (bf == 1)
        {
            subR->_bf = 0;
            parent->_bf = -1;
            subRL->_bf = 0;
        }
        else if (bf == -1)
        {
            subR->_bf = 1;
            parent->_bf = 0;
            subRL->_bf = 0;
        }
        else if (bf == 0)
        {
            subR->_bf = 0;
            parent->_bf = 0;
            subRL->_bf = 0;
        }
        else
        {
            assert(false);
        }
    }

4、判断是否平衡

这里还是进行一个封装，因为不太好穿私有变量，所以这里也就是利用函数进行封装了，如下方代码所示，是否出现错误就是判断高度差，也就是左右高度差不超过2，这里如下方代码所示，在代码旁边注释了了我的思路

void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }

    bool IsBalance()
    {
        return _IsBalance(_root);
    }

    int Height()
    {
        return _Height(_root);
    }
private:
    int _Height(Node* root)//求树的高度
    {
        if (root == NULL)
            return 0;
        int leftH = _Height(root->_left);
        int rightH = _Height(root->_right);
        return leftH > rightH ? leftH + 1 : rightH + 1;
    }

    bool _IsBalance(Node* root)//判断是否出现异常，高度差在2以内
    {
        if (root == NULL)
        {
            return true;
        }
        int leftH = _Height(root->_left);
        int rightH = _Height(root->_right);
        if (rightH - leftH != root->_bf)//判断平衡因子是否出错
        {
            cout << root->_kv.first << "节点平衡因子异常" << endl;
            return false;
        }
        return abs(leftH - rightH) < 2//这里是因为不知道哪个大所以直接求绝对值
            && _IsBalance(root->_left)//因为每条路都需要求一下所以直接递归去求
            && _IsBalance(root->_right);
    }

    void _InOrder(Node* root)//中序遍历
    {
        if (root == nullptr)
        {
            return;
        }
        _InOrder(root->_left);
        cout << root->_kv.first << " ";
        _InOrder(root->_right);
    }

5、测试

这里是利用随机数进行测试是否是平衡，如下方代码和测试结果。

void test()
{
    srand(time(0));
    const size_t N = 500000;
    AVLTree<int, int> t;
    for (size_t i = 0; i < N; ++i)
    {
        size_t x = rand() + i;
        t.Insert(make_pair(x, x));
        //cout << t.IsBalance() << endl;
    }

    //t.Inorder();

    cout << t.IsBalance() << endl;
    cout << t.Height() << endl;
}

 

 

四、代码

#pragma oncetemplate<class K,class V>
struct AVLtreeNode//三叉链
{AVLtreeNode<K, V>* _left;//左孩子AVLtreeNode<K, V>* _right;//右孩子AVLtreeNode<K, V>* _parent;//父母节点pair<K, V> _kv;//键值对，用来存储数据int _bf;//平衡因子，用来平衡AVL树，使他相对像完全二叉树AVLtreeNode(const pair<K, V>& kv):_left(nullptr), _right(nullptr), _parent(nullptr), _kv(kv), _bf(0){}
};template<class K,class V>
class AVLTree
{typedef AVLtreeNode<K,V> Node;//重定义，方便后续节点申请使用
public:bool Insert(const pair<K, V>& kv){if (_root == nullptr)//如果是空节点直接申请，然后返回true{_root = new Node(kv);return true;}Node* parent = nullptr;//记录父节点Node* cur = _root;//记录当前节点while (cur)//遍历去寻找插入的地方{if (cur->_kv.first < kv.first)//大于就去左边寻找{parent = cur;cur = cur->_right;}else if (cur->_kv.first > kv.first)//大于就去右边寻找{parent = cur;cur = cur->_left;}else{return false;//找不到就返回false}}cur = new Node(kv);//创建新的节点if (parent->_kv.first > kv.first)//如果小于就插入在右边{parent->_left = cur;}else if (parent->_kv.first < kv.first)//如果大于就插入到左边{parent->_right = cur;}cur->_parent = parent;//记录一下父节点的地址while (parent)//平衡因子的更新，持续到根{if (cur == parent->_right)//判断新的节点在父节点的左右，如果在右边平衡因子就++，如果在左边就--{parent->_bf++;}else{parent->_bf--;}if (parent->_bf == 1 || parent->_bf == -1)//如果父节点的平衡因子等于1或者-1，接着更新{parent = parent->_parent;cur = cur->_parent;}else if(parent->_bf==0)//如果平衡因子等于0就退出{break;}else if (parent->_bf == 2 || parent->_bf == -2)//超长了，准备旋转了，有四种情况{if (parent->_bf == 2 && cur->_bf == 1)//当父节点的平衡因子等于2当前节点的平衡因子等于1时				{									  //就是相当于右边是一条直线时，然后进行左旋RotateL(parent);//调用左旋函数}else if (parent->_bf == -2 && cur->_bf == -1)//当父平衡因子等于-2当前节点平衡因子等于-1时{												//就是左边时一条直线的情况时，然后进行右旋RotateR(parent);//调用右旋函数}else if (parent->_bf == -2 && cur->_bf == 1)//当父节点平衡因子等于-2时，当前节点的平衡因子等于-1时{											//就是相当于一条折现，就是<这个形状，需要旋转两次，先左旋在右旋RotateLR(parent);//调用先左旋在右旋的函数}else if (parent -> _bf == 2 && cur->_bf == -1)//当父节点平衡因子等于2时，当前节点平衡因子等于-1时{											//就是相当于>这个形状，也是需要旋转两次，先进性右旋在进行左旋RotateRL(parent);//调用先右旋在左旋的函数}else{assert(false);//上述情况都没出现，就说明树已经出现问题了，这里直接利用断言直接报错，断死}break;}else{assert(false);//这里就是更新平衡因子失败，也就是说上述都没，也就是直接报错，因为树也是出现错误了}}return true;}void InOrder(){_InOrder(_root);cout << endl;}bool IsBalance(){return _IsBalance(_root);}int Height(){return _Height(_root);}
private:int _Height(Node* root)//求树的高度{if (root == NULL)return 0;int leftH = _Height(root->_left);int rightH = _Height(root->_right);return leftH > rightH ? leftH + 1 : rightH + 1;}bool _IsBalance(Node* root)//判断是否出现异常，高度差在2以内{if (root == NULL){return true;}int leftH = _Height(root->_left);int rightH = _Height(root->_right);if (rightH - leftH != root->_bf)//判断平衡因子是否出错{cout << root->_kv.first << "节点平衡因子异常" << endl;return false;}return abs(leftH - rightH) < 2//这里是因为不知道哪个大所以直接求绝对值&& _IsBalance(root->_left)//因为每条路都需要求一下所以直接递归去求&& _IsBalance(root->_right);}void _InOrder(Node* root)//中序遍历{if (root == nullptr){return;}_InOrder(root->_left);cout << root->_kv.first << " ";_InOrder(root->_right);}void RotateL(Node* parent)//左旋{Node* subR = parent->_right;//记录父节点的右侧，用来后续旋转Node* subRL = subR->_left;//记录subR的左侧，这个节点比父节点大，比subR小parent->_right = subRL;//因为这个节点比父节点大，所以连接父节点在右边if (subRL)subRL->_parent = parent;//如果subRL节点不是空姐点就把他的父节点置为父节点Node* ppnode = parent->_parent;//记录父节点的父节点subR->_left = parent;//旋转把subR的左节点连接为父节点，因为父节点比subR节点小parent->_parent = subR;//把父节点的父节点置为subRif (ppnode == nullptr)//判断ppnode是否为空也就是之前的父节点是否为根{_root = subR;//如果是根的话，就把subR置为根，在把subR的父节点置为空_root->_parent = nullptr;}else{if (ppnode->_left == parent)//判断ppnode的左节点是否为之前的父节点，如果是就把位置换成subR{ppnode->_left = subR;}else{ppnode->_right = subR;//判断ppnode的右节点是否为之前的父节点，如果是就把位置换成subR}subR->_parent = ppnode;//在进行连接subR的父节点}parent->_bf = subR->_bf = 0;//最后更新平衡因子，因为旋转过后肯定是平衡的所以直接置为0}void RotateR(Node* parent)//右旋，与上面左旋的原理差不多，就是换个方向{Node* subL = parent->_left;Node* subLR = subL->_right;parent->_left = subLR;if (subLR)subLR->_parent = parent;Node* ppnode = parent->_parent;subL->_right = parent;parent->_parent = subL;if (parent == _root){_root = subL;_root->_parent = nullptr;}else{if (ppnode->_left == parent){ppnode->_left = subL;}else{ppnode->_right = subL;}subL->_parent = ppnode;}subL->_bf = parent->_bf = 0;}void RotateLR(Node* parent)//双旋之先左旋在右旋{Node* subL = parent->_left;//记录父节点的左侧Node* subLR = subL->_right;//记录subL的右侧因为形状是<这样的，然后需要先左旋进行掰直int bf = subLR->_bf;//用于记录平衡因子RotateL(parent->_left);//利用左旋函数进行左旋，这里就是把父节点的左侧当成父节点传进去，也就是subLRotateR(parent);//然后在进行右旋if (bf == 1)//更新平衡因子，当前平衡因子如果等于1就把父节点的平衡因子置为0，subLR的为0，因为这个节点在旋转过后{			//就会平衡，但是在bf等于1时，左边肯定是有的，所以subL就是-1parent->_bf = 0;subLR->_bf = 0;subL->_bf = -1;}else if (bf == -1) //在旋转之前平衡因子是-1 的话，在旋转结束时，也就是说明父节点的位置就是需要置为1，因为之前{					//在左，旋转之后就是有右，其他两个就是0parent->_bf = 1;subLR->_bf = 0;subL->_bf = 0;}else if (bf == 0)//如果都是0的话旋转后也是0就直接更新成0{parent->_bf = 0;subLR->_bf = 0;subL->_bf = 0;}else//如果没有就说明树出现问题了直接断言报错{assert(false);}}void RotateRL(Node* parent)//现右旋在左旋与上面差不多{Node* subR = parent->_right;Node* subRL = subR->_left;int bf = subRL->_bf;RotateR(parent->_right);RotateL(parent);if (bf == 1){subR->_bf = 0;parent->_bf = -1;subRL->_bf = 0;}else if (bf == -1){subR->_bf = 1;parent->_bf = 0;subRL->_bf = 0;}else if (bf == 0){subR->_bf = 0;parent->_bf = 0;subRL->_bf = 0;}else{assert(false);}}Node* _root = nullptr;
};void test()
{srand(time(0));const size_t N = 500000;AVLTree<int, int> t;for (size_t i = 0; i < N; ++i){size_t x = rand() + i;t.Insert(make_pair(x, x));//cout << t.IsBalance() << endl;}//t.Inorder();cout << t.IsBalance() << endl;cout << t.Height() << endl;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/826597.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

为啥转化为可编辑面片后有这么多点和线

为啥转化为可编辑面片后有这么多点和线

可以删一下 按住alt按移除可以删掉 选择你要删的那些线 按住alt点移除
阅读更多...
eBay、亚马逊自养号测评如何避免风控账号关联选择合适网络IP环境

eBay、亚马逊自养号测评如何避免风控账号关联选择合适网络IP环境

在自养号下单中选择适合的网络环境至关重要。经过多次实践与测试&#xff0c;积累了大量的经验&#xff0c;希望能够与大家分享&#xff0c;帮助大家避开陷阱&#xff0c;顺利前行。 市面上的网络环境种类繁多&#xff0c;从纯IP类的Luminati、Rola&#xff0c;到纯环境类的VM…
阅读更多...
编写Spark独立应用程序

编写Spark独立应用程序

执行本文之前&#xff0c;先搭建好spark的开发环境&#xff0c;我目前只搭建了standalone模式&#xff0c;参考链接 &#xff1a; Spark Standalone模式部署-CSDN博客 1. 安装sbt 1&#xff09;下载sbt 网址&#xff1a;https://www.scala-sbt.org/download.html &#xff0c…
阅读更多...
【云原生 • Docker】 ELK 8.4.3 docker 保姆级安装部署详细步骤

【云原生 • Docker】 ELK 8.4.3 docker 保姆级安装部署详细步骤

文章目录 ELK简介二、版本说明三、安装部署3.1 创建docker网络3.2 Elasticsearch拉取docker镜像，版本：8.4.3第一次执行docker脚本可以看到控制台的信息，找到这个信息并保存下来创建Elasticsearch挂载目录给创建的文件夹授权将容器内的文件复制到主机上删除容器修改docker脚本…
阅读更多...
【GPTs分享】GPTs分享之Image Recreate | img2img​

【GPTs分享】GPTs分享之Image Recreate | img2img​

简介 该GPT是一个专门用于图像编辑、重建和合并的工具。它通过详细的自动图像描述和生成&#xff0c;帮助用户从源图像中重现或修改图像。此工具设计用于为视障用户提供图像内容的详细描述&#xff0c;并生成全新的图像&#xff0c;以满足特定的视觉需求。 主要功能 \1. 图像…
阅读更多...
Unity开发holoLens2应用时的ProjectSettings配置

Unity开发holoLens2应用时的ProjectSettings配置

正确的进行Unity工程配置&#xff0c;才能进行后续的【发布】和【部署】操作… 本案例开发环境说明&#xff1a; Unity2021.3.18Win10VS2022HoloLens2 一、平台设置 二、Quality画面质量设置 三、Player玩家设置 四、XR-Plug设置 五、环境测试 导入一个官方demo&#xff0c…
阅读更多...
ORAN C平面 Section Extension 23

ORAN C平面 Section Extension 23

ORAN C平面Section扩展23用于任意symbol模式的调制压缩参数。此section扩展允许为一个或多个“SymPrbPatterns”指定多组“mcScaleReMask、csf和mcScaleOffset”值。“SymPrbPattern”用于指定一组PRB&#xff0c;这些PRB可以跨越使用prbPattern指定的整个PRB范围&#xff08;频…
阅读更多...
重生奇迹mu坐骑怎么升级

重生奇迹mu坐骑怎么升级

重生奇迹mu坐骑怎么升级 1、前期&#xff0c;都是主线任务&#xff0c;我们必须要跟着主线任务走&#xff0c;前面的话升级一次需要的经验很少的&#xff0c;一天下来可以升级100级是轻轻松松的&#xff0c;主线任务是比较多的&#xff0c;我们跟着任务一直做差不多可以到150级…
阅读更多...
dspbuilder中使用signalcompiler时报错Error during compilation: Fitter failed，如何解决？

dspbuilder中使用signalcompiler时报错Error during compilation: Fitter failed，如何解决？

&#x1f3c6;本文收录于「Bug调优」专栏&#xff0c;主要记录项目实战过程中的Bug之前因后果及提供真实有效的解决方案&#xff0c;希望能够助你一臂之力&#xff0c;帮你早日登顶实现财富自由&#x1f680;&#xff1b;同时&#xff0c;欢迎大家关注&&收藏&&…
阅读更多...
计算机组成原理【CO】Ch7 I/O大题

计算机组成原理【CO】Ch7 I/O大题

目录 I/O大题解题方法 I/O接口 各种I/O方式的特点 I/O端口编址 程序查询方式 中断控制方式 DMA控制方式 程序中断的工作流程 程序中断的工作流程 DMA方式和中断方式的区别 I/O大题解题方法 CPU 程序查询中断DMA I/O接口的类型 按字传输&#xff1a;每次传输一个字 程…
阅读更多...
【C++】日期类Date（详解）

【C++】日期类Date（详解）

&#x1f525;个人主页&#xff1a;Forcible Bug Maker &#x1f525;专栏&#xff1a;C 目录 前言 日期类 日期类实现地图 获取某年某月的天数&#xff1a;GetMonthDay 检查日期合法&#xff0c;构造函数&#xff0c;拷贝构造函数&#xff0c;赋值运算符重载及析构函数…
阅读更多...
【数据结构2-线性表】

【数据结构2-线性表】

数据结构2-线性表 1 线性表-数组2 线性表-单链式结构2.1 前插顺序单链表2.2 后插顺序单链表2.3 循环单链表2.4 双向链表 总结 线性表、栈、队列、串和数组都属于线性结构。 线性结构的基本特点是除第一个元素无直接前驱&#xff0c;最后一个元素无直接后继之外&#xff0c;其他…
阅读更多...
.net反射（Reflection）

.net反射（Reflection）

文章目录 一.概念&#xff1a;二.反射的作用&#xff1a;三.代码案例&#xff1a;四.运行结果&#xff1a; 一.概念&#xff1a; .NET 反射&#xff08;Reflection&#xff09;是指在运行时动态地检查、访问和修改程序集中的类型、成员和对象的能力。通过反射&#xff0c;你可…
阅读更多...
【游戏专区】飞机大战

【游戏专区】飞机大战

打过飞机的人都知道&#xff0c;不是那么好打滴&#xff0c;求得麻袋&#xff0c;甩掉你那脑子里的黄色信息。活不多说&#xff0c;我们开始吧。 1、easyX的原理 基于Windows图形编程&#xff0c;将Windows下的复杂程序过程进行封装&#xff0c;仅给用户提供一个简单熟悉的接…
阅读更多...
21.组件组成

21.组件组成

组件组成 组件最大的优势就是可复用性 当使用构建步骤时&#xff0c;我们一般会将 Vue 组件定义在一个单独的 .vue 文件中&#xff0c;这被叫做单文件组件(简称 SFC) 组件组成结构 <template><div>承载标签</div> </template> <script> expor…
阅读更多...
【软件测试】正交表测试例题

【软件测试】正交表测试例题

【软件测试】正交表测试 例题1答案 例题2答案 例题3答案 例题1 很多Word编辑器都有字体修饰功能&#xff0c;可以将一个字加粗、倾斜、以及加上下划线。一个字可以同时被加粗和倾斜&#xff0c;也可以同时被倾斜和加下划线。三种因子Bold, Italic, Underline的效果可以任意组合…
阅读更多...
计算机组成原理【CO】Ch3 存储系统

计算机组成原理【CO】Ch3 存储系统

文章目录 考纲3.1 存储系统概述3.2 主存储器3.3 主存储器与CPU的连接3.4 外部存储器3.5 高速缓冲存储器3.6 虚拟存储器 【※】存储系统总体流程图【※】各个部件的存储位置计算机存储相关硬件与数据结构说明进程控制块&#xff08;PCB&#xff09;页表页表始址页表始址寄存器&a…
阅读更多...
传感器融合 | 适用于自动驾驶场景的激光雷达传感器融合项目_将激光雷达的高分辨率成像+测量物体速度的能力相结合

传感器融合 | 适用于自动驾驶场景的激光雷达传感器融合项目_将激光雷达的高分辨率成像+测量物体速度的能力相结合

项目应用场景 面向自动驾驶场景的激光雷达传感器融合&#xff0c;将激光雷达的高分辨率成像测量物体速度的能力相结合&#xff0c;项目是一个从多个传感器获取数据并将其组合起来的过程&#xff0c;可以更加好地进行环境感知。项目支持 ubuntu、mac 和 windows 平台。 项目效果…
阅读更多...
CGLIB动态代理

CGLIB动态代理

文章目录 前言概要SpringBoot中使用小结 前言 当我们需要在Java中实现动态代理时&#xff0c;通常会考虑使用 JDK原生动态代理 或者 CGLIB动态代理。 我这里说一下CGLIB动态代理&#xff0c;并给出一个例子。 概要 CGLIB&#xff08;Code Generation Library&#xff09;是一…
阅读更多...
ROS分布式通讯配置

ROS分布式通讯配置

4WD 必读&#xff1a;分布式通讯是相对于用虚拟机来连接小车上主机来说&#xff0c;如果是 4WD 笔记本无主 机用户&#xff0c;不存在分布式通讯一说。 1.4WD 用户单笔记设置一&#xff0c;连接底盘和雷达还有摄像头。 因为虚拟机带宽问题&#xff0c;无法保证摄像头正常运行。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023