AVL 树

AVL树的概念

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

一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

它的左右子树都是AVL树
左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

节点的平衡因子=右子树的高度-左子树的高度

例如：
下图的二叉搜索树的每个节点的平衡因子的 绝对值都小于2，并且每个节点的子树也都是AVL树
在这里插入图片描述

AVL树的定义

AVL树是一种特殊的二叉搜索树，它具有高度的平衡，所以为了在插入过程中的各个节点的平衡因子的更新，我们在定义AVL树的节点结构的同时要带上一个节点的双亲结点parent

template<class T>
struct AVLTreeNode
{
    AVLTreeNode(const T& data)
        : _left(nullptr), _right(nullptr), _parent(nullptr)
        , _data(data), _bf(0)
    {}
    AVLTreeNode<T>* _left;   // 该节点的左孩子
    AVLTreeNode<T>* _right;  // 该节点的右孩子
    AVLTreeNode<T>* _parent; // 该节点的双亲
    T _data;
    int _bf;                  // 该节点的平衡因子
};
AVL树的插入

AVL树的插入是一个难点，它分为好几种情况，其实AVL树的插入也就是在二叉搜索树中插入新节点，但是由于他引入了平衡因子，需要更新，所以这里的插入节点就比较麻烦，她一共分为两步：

1 插入节点
2 更新节点的平衡因子

为什么要更新节点的平衡因子呢？

简单地举个例子：
如图所示，我将一个新节点插入0的左孩子节点的位置，那么以3为节点的这颗子树的高度差不就会超过1了吗，他的左子树的高度插入新节点后为3，而右子树为1，这就不符合AVL树的性质了，所以我们需要经过一些操作来更新平衡因子
在这里插入图片描述

这里大家需要注意一个规则：
新节点如果是插入后他的parent的左侧，那么他的平衡因子默认是+1
反之插入他的右侧就是默认-1

那么在插入节点后，各个插入节点的parent一共就有三种情况了：

平衡因子为0
如果parent的平衡因子为0，说明插入之前parent的平衡因子为正负1，插入后被调整成0，此时满足AVL树的性质，插入成功

平衡因子为正负1
如果parent的平衡因子为正负1，说明插入前pParent的平衡因子一定为0，插入后被更新成正负1，此时以parent为根的树的高度增加，需要继续向上更新，防止部分节点的左右子树高度差超过1
平衡因子为正负2
如果parent的平衡因子为正负2，则pParent的平衡因子违反平衡树的性质，需要对其进行旋转处理，旋转处理之后插入成功

至于旋转的情况我们待会分析，我们先将插入节点的代码的主要框架构造出来：
这样一个简单的框架就构造出来了

template<class T>
struct AVLTreeNode
{
    
    AVLTreeNode<T>* _left;   // 该节点的左孩子
    AVLTreeNode<T>* _right;  // 该节点的右孩子
    AVLTreeNode<T>* _parent; // 该节点的双亲
    T _data;
    int _bf;                  // 该节点的平衡因子
    AVLTreeNode(const T& data)
        : _left(nullptr), _right(nullptr), _parent(nullptr)
        , _data(data), _bf(0)
    {}
};
template<class T>
class AVLTree
{

    typedef AVLTreeNode<T> Node;
public:
    
    bool insert(const T& data)
    {
        if (_root == nullptr)
        {
            _root = new Node(data);
            return true;
        }
        Node* parent = nullptr;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_data < data)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_data > data)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return false;
            }
            cur = new Node(data);
            if (parent->_data > data)
            {
                parent->_left = cur;
            }
            else
            {
                parent->_right = cur;
            }
            while (parent)
            {
                //左边++
                if (cur == parent->_left)
                {
                    parent->_bf--;
                }
                //右边--
                else
                {
                    parent->_bf++;
                }
                //parent的平衡因子等于0，插入成功
                if (parent->_bf == 0)
                {
                    break;
                }
                //parent的平衡因子等于1或者-1，继续向上更新
                else if (parent->_bf == 1 || parent->_bf == -1)
                {
                    cur = parent;
                    parent = parent->_parent;
                }
                else if (parent->_bf == 2 || parent->_bf == -2)
                {
                    //需要进行旋转
                }
                else
                {
                    assert(false);
                }
            }
        }
    }


private:
    Node* _root;
};

下面我们就具体分析几种旋转的情况

AVL树的旋转

如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，使之平衡化。根据节点插入位置的不同，AVL树的旋转分为四种：

1. 新节点插入较高左子树的左侧—左左：右单旋
下图中的h可以时0 1 2三种，分别代表了这三个子树的高度，无论他是等于0 1 还是2时他们都可以满足AVL树的要求
在这里插入图片描述
可以看到，这种情况就是parent的平衡因子等于-2，cur的平衡因子等于-1
左旋函数如下：

void RotateR(Node* parent)
{
    Node* subL = parent->_left;
    Node* subLR = subL->_right;

    parent->_left = subLR;
    //防止sublr为空
    if(subLR)
        subLR->_parent = parent;
    //记录祖父位置
    Node* pparent = parent->_parent;
    
    subL->_right = parent;
    parent->_parent = subL;
    //如果父亲是根节点
    if (parent == _root)
    {
        _root = subL;
        subL->_parent = nullptr;
    }
    //parent不是根节点，那么祖父就会成为subl的parent
    else
    {
        if (pparent->_left == parent)
        {
            pparent->_left = subL;
            subL->_parent = pparent;
        }
        else
        {
            pparent->_right = subL;
            subL->_parent = pparent;
        }
    }
    //旋转后parent和subl的 平衡因子都会更新为0
    parent->_bf = subL->_bf = 0;
}

2. 新节点插入较高右子树的右侧—右右：左单旋
实现及情况考虑可参考右单旋。
在这里插入图片描述

void RotateL(Node* parent)
{
    Node* subR = parent->_right;
    Node* subRL = subR->_left;

    parent->_right = subRL;
    subR->_left = parent;

    Node* pparent = parent->_parent;
    
    if (subRL)
        subRL->_parent = parent;

    if (_root == parent)
    {
        _root = subR;
        subR->_parent == nullptr;
    }
    else
    {
        if (pparent->_left == parent)
        {
            pparent->_left = subR;
            subR->_parent = pparent;
        }
        else
        {
            pparent->_right = subR;
            subR->_parent = pparent;
        }
    }
    parent->_bf = subR->_bf = 0;
}

3. 新节点插入较高左子树的右侧—左右：先左单旋再右单旋
在这里插入图片描述
将双旋变成单旋后再旋转，即：先对30进行左单旋，然后再对90进行右单旋，旋转完成后再考虑平衡因子的更新。
直接复用即可：
由于博主能力有限，所以放入代码大家仔细理解

void RotateLR(Node* parent)
{
    Node* subL = parent->_left;
    Node* subLR = subL->_right;

    RotateL(parent->_left);
    RotateR(parent);
    
    int bf = subLR->_bf;
    //sublr就是新增节点
    if (bf == 0)
    {
        parent->_bf = 0;
        subL->_bf = 0;
        subLR->_bf = 0;
    }
    //sublr左子树新增节点
    else if (bf == -1)
    {
        parent->_bf = 1;
        subL->_bf = 0;
        subLR->_bf = 0;
    }
    //sublr右子树新增节点
    else if (bf == 1)
    {
        parent->_bf = 0;
        subL->_bf = -1;
        subLR->_bf = 0;
    }
    else
    {
        assert(false);
    }
}

4. 新节点插入较高右子树的左侧—右左：先右单旋再左单旋
在这里插入图片描述

void RotateRL(Node* parent)
{
    Node* subR = parent->_right;
    Node* subRL = subR->_left;
    int bf = subRL->_bf;
    RotateR(parent->_right);
    RotateL(parent);
    //subrl这个点为新增点
    if (bf == 0)
    {
        parent->_bf = subR->_bf = subRL->_bf = 0;
    }
    //subrl的左子树新增
    else if (bf == -1)
    {
        parent->_bf = 0;
        subRL->_bf = 0;
        subR->_bf = 1;
    }
    //subrl的右子树新增
    else if (bf == 1)
    {
        parent->_bf = -1;
        subRL->_bf = 0;
        subR->_bf = 0;
    }
    else
    {
        assert(false);
    }
}

根据各种情况我们做了总结：

假如以parent为根的子树不平衡，即parent的平衡因子为2或者-2，分以下情况考虑

  1. parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR，当subR的平衡因子为1时，执行左单旋当subR的平衡因子为-1时，执行右左双旋
  2. parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL，当subL的平衡因子为-1是，执行右单旋，当subL的平衡因子为1时，执行左右双旋旋转完成后，原parent为根的子树个高度降低，已经平衡，不需要再向上更新。

所以我们可以补全上面的插入节点的代码了：

bool insert(const T& data)
{
    if (_root == nullptr)
    {
        _root = new Node(data);
        return true;
    }
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
        if (cur->_data < data)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (cur->_data > data)
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {
            return false;
        }
        
    }
    cur = new Node(data);
    if (parent->_data > data)
    {
        parent->_left = cur;
    }
    else
    {
        parent->_right = cur;
    }
    while (parent)
    {
        //左边++
        if (cur == parent->_left)
        {
            parent->_bf--;
        }
        //右边--
        else
        {
            parent->_bf++;
        }
        //parent的平衡因子等于0，插入成功
        if (parent->_bf == 0)
        {
            break;
        }
        //parent的平衡因子等于1或者-1，继续向上更新
        else if (parent->_bf == 1 || parent->_bf == -1)
        {
            cur = parent;
            parent = parent->_parent;
        }
        else if (parent->_bf == 2 || parent->_bf == -2)
        {
            //需要进行旋转
            if (parent->_bf == 2 && cur->_bf == 1)
            {
                RotateL(parent);
            }
            else if (parent->_bf == 2 && cur->_bf == -1)
            {
                RotateRL(parent);
            }
            else if (parent->_bf == -2 && cur->_bf == -1)
            {
                RotateR(parent);
            }
            else if (parent->_bf == -2 && cur->_bf == 1)
            {
                RotateLR(parent);
            }
            break;
        }
        else
        {
            assert(false);
        }
    }
    return true;
}
AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：

1. 验证其为二叉搜索树
如果中序遍历可得到一个有序的序列，就说明为二叉搜索树
2. 验证其为平衡树每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)节点的平衡因子是否计算正确

我们可以用一个函数来判断即可：
首先要有一个计算树的高度的函数
然后判断他们的子树的高度差的绝对值是否在2以内，并且他们的子树也要是AVL树

int Height(Node* root)
{
    if (root == nullptr)
    {
        return 0;
    }
    int leftheight = Height(root->_left);
    int rightheight = Height(root->_right);
    return leftheight > rightheight ? leftheight + 1 : rightheight + 1;
}

bool isbalance()
{
    return _isbalance(_root);
}

bool _isbalance(Node* root)
{
    if (root == nullptr)
        return true;
    int leftheight = Height(root->_left);
    int rightheight = Height(root->_right);
    if (rightheight - leftheight != root->_bf)
    {
        cout << root->_data << "平衡因子异常" << endl;
        return false;
    }
    return abs(rightheight - leftheight) < 2
        && _isbalance(root->_left)
        && _isbalance(root->_right);
}

我们还可以用中序遍历打印：

void inorder()
{
    _inorder(_root);
    cout << endl;
}

void _inorder(Node* root)
{
    if (root == nullptr)
    {
        return;
    }
    _inorder(root->_left);
    cout << root->_data << " ";
    _inorder(root->_right);
}

在这里插入图片描述
完整代码如下：

#include<iostream>
#include<assert.h>
using namespace std;
template<class T>
struct AVLTreeNode
{
    
    AVLTreeNode<T>* _left;   // 该节点的左孩子
    AVLTreeNode<T>* _right;  // 该节点的右孩子
    AVLTreeNode<T>* _parent; // 该节点的双亲
    T _data;
    int _bf;                  // 该节点的平衡因子
    AVLTreeNode(const T& data)
        : _left(nullptr), _right(nullptr), _parent(nullptr)
        , _data(data), _bf(0)
    {}
};
template<class T>
class AVLTree
{

    typedef AVLTreeNode<T> Node;
public:
    
    bool insert(const T& data)
    {
        if (_root == nullptr)
        {
            _root = new Node(data);
            return true;
        }
        Node* parent = nullptr;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_data < data)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_data > data)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return false;
            }
            
        }
        cur = new Node(data);
        if (parent->_data > data)
        {
            parent->_left = cur;
        }
        else
        {
            parent->_right = cur;
        }
        while (parent)
        {
            //左边++
            if (cur == parent->_left)
            {
                parent->_bf--;
            }
            //右边--
            else
            {
                parent->_bf++;
            }
            //parent的平衡因子等于0，插入成功
            if (parent->_bf == 0)
            {
                break;
            }
            //parent的平衡因子等于1或者-1，继续向上更新
            else if (parent->_bf == 1 || parent->_bf == -1)
            {
                cur = parent;
                parent = parent->_parent;
            }
            else if (parent->_bf == 2 || parent->_bf == -2)
            {
                //需要进行旋转
                if (parent->_bf == 2 && cur->_bf == 1)
                {
                    RotateL(parent);
                }
                else if (parent->_bf == 2 && cur->_bf == -1)
                {
                    RotateRL(parent);
                }
                else if (parent->_bf == -2 && cur->_bf == -1)
                {
                    RotateR(parent);
                }
                else if (parent->_bf == -2 && cur->_bf == 1)
                {
                    RotateLR(parent);
                }
                break;
            }
            else
            {
                assert(false);
            }
        }
        return true;
    }

    void RotateR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;

        parent->_left = subLR;
        //防止sublr为空
        if(subLR)
            subLR->_parent = parent;
        //记录祖父位置
        Node* pparent = parent->_parent;
        
        subL->_right = parent;
        parent->_parent = subL;
        //如果父亲是根节点
        if (parent == _root)
        {
            _root = subL;
            subL->_parent = nullptr;
        }
        //parent不是根节点，那么祖父就会成为subl的parent
        else
        {
            if (pparent->_left == parent)
            {
                pparent->_left = subL;
                subL->_parent = pparent;
            }
            else
            {
                pparent->_right = subL;
                subL->_parent = pparent;
            }
        }
        //旋转后parent和subl的 平衡因子都会更新为0
        parent->_bf = subL->_bf = 0;
    }

    void RotateL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;

        parent->_right = subRL;
        subR->_left = parent;

        Node* pparent = parent->_parent;
        
        if (subRL)
            subRL->_parent = parent;

        if (_root == parent)
        {
            _root = subR;
            subR->_parent == nullptr;
        }
        else
        {
            if (pparent->_left == parent)
            {
                pparent->_left = subR;
                subR->_parent = pparent;
            }
            else
            {
                pparent->_right = subR;
                subR->_parent = pparent;
            }
        }
        parent->_bf = subR->_bf = 0;
    }

    void RotateLR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;

        RotateL(parent->_left);
        RotateR(parent);
        
        int bf = subLR->_bf;
        //sublr就是新增节点
        if (bf == 0)
        {
            parent->_bf = 0;
            subL->_bf = 0;
            subLR->_bf = 0;
        }
        //sublr左子树新增节点
        else if (bf == -1)
        {
            parent->_bf = 1;
            subL->_bf = 0;
            subLR->_bf = 0;
        }
        //sublr右子树新增节点
        else if (bf == 1)
        {
            parent->_bf = 0;
            subL->_bf = -1;
            subLR->_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);
        //subrl这个点为新增点
        if (bf == 0)
        {
            parent->_bf = subR->_bf = subRL->_bf = 0;
        }
        //subrl的左子树新增
        else if (bf == -1)
        {
            parent->_bf = 0;
            subRL->_bf = 0;
            subR->_bf = 1;
        }
        //subrl的右子树新增
        else if (bf == 1)
        {
            parent->_bf = -1;
            subRL->_bf = 0;
            subR->_bf = 0;
        }
        else
        {
            assert(false);
        }
    }

    int Height(Node* root)
    {
        if (root == nullptr)
        {
            return 0;
        }
        int leftheight = Height(root->_left);
        int rightheight = Height(root->_right);
        return leftheight > rightheight ? leftheight + 1 : rightheight + 1;
    }

    bool isbalance()
    {
        return _isbalance(_root);
    }

    bool _isbalance(Node* root)
    {
        if (root == nullptr)
            return true;
        int leftheight = Height(root->_left);
        int rightheight = Height(root->_right);
        if (rightheight - leftheight != root->_bf)
        {
            cout << root->_data << "平衡因子异常" << endl;
            return false;
        }
        return abs(rightheight - leftheight) < 2
            && _isbalance(root->_left)
            && _isbalance(root->_right);
    }

    void inorder()
    {
        _inorder(_root);
        cout << endl;
    }

    void _inorder(Node* root)
    {
        if (root == nullptr)
        {
            return;
        }
        _inorder(root->_left);
        cout << root->_data << " ";
        _inorder(root->_right);
    }

private:
    Node* _root=nullptr;
};

好了，今天的分享到这里就结束了，感谢大家的支持！

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

vue3的router

vue3的router

需求 路由组件一般放在&#xff0c;pages或views文件夹, 一般组件通常放在component文件夹 路由的2中写法 子路由 其实就是在News组件里面&#xff0c;再定义一个router-view组件 他的子组件&#xff0c;机会渲染在router-view区域 路由传参 <RouterLink :to"/news…
阅读更多...
腾讯云最新活动_腾讯云促销优惠_代金券-腾讯云官网入口

腾讯云最新活动_腾讯云促销优惠_代金券-腾讯云官网入口

腾讯云服务器多少钱一年&#xff1f;62元一年起&#xff0c;2核2G3M配置&#xff0c;腾讯云2核4G5M轻量应用服务器218元一年、756元3年&#xff0c;4核16G12M服务器32元1个月、312元一年&#xff0c;8核32G22M服务器115元1个月、345元3个月&#xff0c;腾讯云服务器网txyfwq.co…
阅读更多...
xsslabs第七关

xsslabs第七关

源码 <!DOCTYPE html><!--STATUS OK--><html> <head> <meta http-equiv"content-type" content"text/html;charsetutf-8"> <script> window.alert function() { confirm("完成的不错&#xff01;"…
阅读更多...
《2023年勒索软件攻击态势报告》

《2023年勒索软件攻击态势报告》

获取方式&#xff1a; 链接&#xff1a;https://pan.baidu.com/s/1zd-yVsuGwJADyyGNFR_TIQ?pwd2lo0 提取码&#xff1a;2lo0
阅读更多...
游戏空间划分技术

游戏空间划分技术

一、 前言 空间划分算法有很多&#xff0c;比如均匀网格&#xff0c;四/八叉树&#xff0c;k-d树&#xff0c;Bsp树&#xff0c;每一种算法都有自己的优缺点&#xff0c;我们需要从理论上理解这些算法&#xff0c;然后在实际项目中进行灵活的运用。 游戏中经常使用空间划分算…
阅读更多...
k8s二进制部署的搭建

k8s二进制部署的搭建

1.1 常见k8s安装部署方式 ●Minikube Minikube是一个工具&#xff0c;可以在本地快速运行一个单节点微型K8S&#xff0c;仅用于学习、预览K8S的一些特性使用。 部署地址&#xff1a;Install Tools | Kubernetes ●Kubeadm Kubeadm也是一个工具&#xff0c;提供kubeadm init…
阅读更多...
【前端素材】推荐优质后台管理系统网页Hyper平台模板（附源码）

【前端素材】推荐优质后台管理系统网页Hyper平台模板（附源码）

一、需求分析 1、系统定义 后台管理系统是一种用于管理和控制网站、应用程序或系统的管理界面。它通常被设计用来让网站或应用程序的管理员或运营人员管理内容、用户、数据以及其他相关功能。后台管理系统是一种用于管理网站、应用程序或系统的工具&#xff0c;通常由管理员使…
阅读更多...
Charles抓包 - 安装、激活、证书配置

Charles抓包 - 安装、激活、证书配置

最近刚好又遇到了抓包的需求&#xff0c;之前一直使用 Fiddler 抓包&#xff0c;这几年一直听大家都在用 Charles 抓包&#xff0c;正好一起了解下&#xff08;一般建议掌握一种抓包方式即可&#xff0c;都可以解决同种需求场景&#xff09; 抓包 Fiddler抓包 Charles 下载、安…
阅读更多...
深度解读篇章：剖析构建互联网大厦的基石——TCP/IP协议全貌

深度解读篇章：剖析构建互联网大厦的基石——TCP/IP协议全貌

&#x1f440;&#x1f440;&#x1f440; 引言 今天&#xff0c;我们一同揭幕的是驱动全球互联网脉搏跳动的核心机密——TCP/IP协议体系。没有它&#xff0c;就不会有现今这般高效便捷的网络生活体验&#xff0c;无论在线教育、远程办公&#xff0c;抑或是电子商务、社交媒体…
阅读更多...
强大而灵活的python装饰器

强大而灵活的python装饰器

装饰器&#xff08;Decorators&#xff09; 一、概述 在Python中&#xff0c;装饰器是一种特殊类型的函数&#xff0c;它允许我们修改或增强其他函数的功能&#xff0c;而无需修改其源代码。装饰器在函数定义之后立即调用&#xff0c;并以函数对象作为参数。装饰器返回一个新…
阅读更多...
Docker容器与虚拟化技术：OpenEuler 部署 docker容器应用

Docker容器与虚拟化技术：OpenEuler 部署 docker容器应用

目录 一、实验 1.环境 2.OpenEuler 安装 docker 2.镜像加速 3.docker部署LAMP 二、安装docker报错 2.docker如何快速删除容器与镜像 3.docker创建mysql容器失败 4.docker创建apache容器失败 5.docker创建php-fpm容器失败 6. 80端口与php访问失败 7.httpd容器进入不…
阅读更多...
【刷题】Leetcode 1609.奇偶树

【刷题】Leetcode 1609.奇偶树

Leetcode 1609.奇偶树 题目描述广度优先搜索&#xff08;BFS&#xff09;深度优先算法&#xff08;DFS&#xff09; 思路一&#xff08;BFS&#xff09;思路二&#xff08;DFS&#xff09;Thanks♪(&#xff65;ω&#xff65;)&#xff89;谢谢阅读&#xff01;&#xff01;&a…
阅读更多...
【k8s管理--Helm包管理器】

【k8s管理--Helm包管理器】

1、Helm的概念 Kubernetes包管器 Helm是查找、分享和使用软件构件Kubernetes的最优方式。 Helm管理名为chart的Kubernetes包的工具。Helm可以做以下的事情&#xff1a; 从头开始创建新的chat将chart打包成归档tgz)文件与存储chat的仓库进行交互在现有的Kubernetes集群中安装和…
阅读更多...
【数据库管理系统】Mysql 8.0.36入门级安装

【数据库管理系统】Mysql 8.0.36入门级安装

下载地址 官方网址&#xff1a;MySQL 注意事项 建议不要安装最新版本&#xff0c;一般找mysql5.0或mysql8.0系列版本即可&#xff1b;mysq1官网有.zip和.msi两种安装形式&#xff1b;zip是压缩包&#xff0c;直接解压缩以后使用的&#xff0c;需要自己配置各种东西&#xff…
阅读更多...
模型优化_如何提高网络/模型的泛化能力？(全面)

模型优化_如何提高网络/模型的泛化能力？(全面)

目录 1. 以数据为中心的泛化方法 1.1 使用更多数据 1.2 做好数据预处理 特征工程 1.3 数据增强 1.4 调整数据分布 2. 以模型为中心的泛化方法 2.1 使用更大批次 超参数调优 2.2 调整目标函数 2.3 调整网络结构 2.4 屏蔽网络节点 2.5 权值正则化 2.6 偏差-方差权衡…
阅读更多...
计算机网络_2.2物理层下面的传输媒体

计算机网络_2.2物理层下面的传输媒体

2.2物理层下面的传输媒体 一、传输媒体的分类二、导向型传输媒体1、同轴电缆2、双绞线3、光纤&#xff08;1&#xff09;光纤通信原理&#xff08;2&#xff09;光纤组成&#xff08;4&#xff09;多模光纤与单模光纤对比&#xff08;5&#xff09;光纤的波长与规格&#xff08…
阅读更多...
自测-1 打印沙漏

自测-1 打印沙漏

文章预览&#xff1a; 题目算法代码 题目 算法 以前做过这个&#xff0c;那次是c语言写的&#xff0c;一点一点处理一层一层完成&#xff0c;这次我换了一种语言用了另一种思想使用递归去写&#xff0c;还是我们要先求出应该有多少层这个很容易&#xff0c;中间输出部分我们算…
阅读更多...
Linux系统中安装redis+redis后台启动+常见相关配置

Linux系统中安装redis+redis后台启动+常见相关配置

1、下载Redis Redis官网&#xff1a;https://redis.io/ 历史版本&#xff1a; http://download.redis.io/releases 2、连接Linux&#xff08;或者VMwear&#xff09; 我们安装的是linux版本的redis 打开xftp我们需要先将我们的Redis上传到服务器上 解压到这里 解压的指令 …
阅读更多...
回归预测 | Matlab实现BiTCN基于双向时间卷积网络的数据回归预测

回归预测 | Matlab实现BiTCN基于双向时间卷积网络的数据回归预测

回归预测 | Matlab实现BiTCN基于双向时间卷积网络的数据回归预测 目录 回归预测 | Matlab实现BiTCN基于双向时间卷积网络的数据回归预测效果一览基本介绍程序设计参考资料 效果一览 基本介绍 1.Matlab实现BiTCN基于双向时间卷积网络的数据回归预测&#xff08;完整源码和数据&a…
阅读更多...
SpringBoot原理-配置优先级(黑马学习笔记)

SpringBoot原理-配置优先级(黑马学习笔记)

配置优先级 在我们前面的课程当中&#xff0c;我们已经讲解了SpringBoot项目当中支持的三类配置文件&#xff1a; ● application.properties ● application.yml ● application.yaml 在SpringBoot项目当中&#xff0c;我们要想配置一个属性&#xff0c;可以通过这三种方…
阅读更多...
最新文章

Copyright @ 2022~2023