AVL树

最新推荐文章于 2024-11-13 21:08:14 发布
最新推荐文章于 2024-11-13 21:08:14 发布
阅读量574 收藏 13
点赞数 8
分类专栏： 数据结构 文章标签： c++ 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FBI_BAIGOU/article/details/136000682
版权

文章目录


AVL树是对普通二叉搜索树的一种优化。当二叉搜索树插入的元素是有序的时候或者接近有序的时候，二叉搜索树的性能会大大降低。二叉搜索树可能会变成一个歪脖子树。比如下图：

image.png
关于二叉搜索树 之前博客有介绍。二叉搜索树(BST)

为了解决这个问题，俄罗斯两位数学家，G.M.Adelson-Velskii和E.M.Landis在1962年共同发明了一种解决平衡二叉树的算法。同时也根据两位数学家的名字命名为AVL树

AVL树

AVL树是一种叉排序树，其中每个结点的左子树和右子树高度差最多为1
AVL树要么是一颗空树，要么左子树和右子树都是AVL树，且左右子树的高度之差的绝对值不超过1
比如下面图1就不是AVL树，图二就是AVL树

image.png
图1 结点58左子树高度为3，右子树高度为0。左右子树的高度差为3，不合符AVL树的性质。
image.png

平衡因子

将二叉树中的右子树的高度减去左子树的高度的值称为平衡因子BF(balance factor)。(也可以是左子树减去右子树的高度)

如果一棵树是AVL树，那么这棵树上的所有结点的平衡因子只可能是 0、1、-1。

比如上面图1各结点的平衡因子如下：
这里以右子树减左子树作为BF为例

image.png
结点58的平衡因子是-3，很明显不是AVL树
图二各结点的平衡因子如下

image.png

各结点的平衡因子只有0、1、-1。所以这是棵AVL树。

AVL树结点的定义

这里直接实现KV模型的AVL树。用pair键值对作为树的元素值。为了后续实现更简单将AVL树定义为三叉链的结构(左子树，右子树，父结点)。并且在结点中引入平衡因子。

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;//结点的平衡因子
	
	AVLTreeNode(const pair<K,V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_bf(0)
	{}
};

AVL树类和函数接口

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	AVLTree()
		:_root(nullptr)
	{}

	bool insert(const pair<K, V>& kv)
private:
	Node* _root;
};

AVL树插入元素

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树的插入也可以看成是二叉搜索树的插入。那么 AVL树的插入过程可以分为两步：

  • 按照二叉搜索树的方式进行插入
  • 调整该结点的平衡因子
    • 调整完该结点的平衡因子之后，如果出现不平衡(BF不等于0、1、-1)，组要进行旋转处理，让继续成为AVL树。
    • 调整完该结点的平衡因子之后，如果平衡因子依然是0、1、-1 ,则无需处理。

如何调整结点的平衡因子：

  • 当插入的结点时当前结点的左孩子：让BF–(这里的BF以右减左为基准);
    比如下面对62插入一个47结点。62的BF从0变为-1；
    image.png

  • 当插入的结点是当前结点的右孩子：让BF++;
    比如对下面这颗树插入88，62的BF从-1变为0
    image.png

如果插入完之后当前结点的FB为0。说明插入后这棵树左右子树高度已经平衡则无需处理。(说明之前一边高一边低，插入之后正好平衡);
比如下面对47结点插入51之后，结点47的BF从-1 变为 0 。刚好平衡无需处理。
image.png

如果插入完之后当前节点的BF为1或者-1。说明高度变了(之前的BF为0 已经平衡，插入之后一边高一边低)，这时候需要更新父结点的BF。

比如对下面35结点插入30之后，35的BF从0变为-1, 35的父结点47也从0变为-1，根节点从-1变为了-2。此时就要更新自己的父结点以及祖宗结点，然后根据父结点或者祖宗结点的BF来判断下一步操作。
image.png

如果更新完父节点以及组宗结点的BF为2或者-2。则说明已经不是AVL树了。此时就需要进行旋转处理了。

比如上面插入30之后，祖宗结点的BF为-2；就需要进行旋转处理 使之平衡。如何旋转，后面会详细介绍。
下面先实现插入和调整平衡因子的代码

代码实现：

bool insert(const pair<K, V>& kv)
{
        //空树，直接作为根节点
        if (_root == nullptr)
        {
                _root = new Node(kv);
                return true;
        }

        //按照二叉搜索树的插入进行插入
        Node* cur = _root;
        Node* parent = nullptr;
        //确定插入结点的位值
        while (cur != nullptr)
        {
                if ((kv.first) < (cur->_kv.first))//待插入结点Key小于当前结点的Key
                {
                        parent = cur;
                        cur = cur->_left;
                }
                else if ((kv.first) > (cur->_kv.first))
                {
                        parent = cur;
                        cur = cur->_right;
                }
                else//Key值冗余 不允许插入
                {
                        return false;
                }
        }

        //链接 
        cur = new Node(kv);
        //确定插入结点的位置，在父结点的左边还是右边
        if (kv.first < parent->_kv.first)
        {
                parent->_left = cur;
        }
        else
        {
                parent->_right = cur;
        }
        cur->_parent = parent;


        //调整平衡因子
        while (parent != nullptr)
        {
                //插入到右子树中将BF++
                if (cur == parent->_right)
                {
                        parent->_bf++;
                }
                //插入到左子树中 将BF--
                else if (cur == parent->_left)
                {
                        parent->_bf--;
                }
                
                //BF为0 说明已经平衡 无需处理
                if (parent->_bf == 0)
                {
                        break;
                }
                // BF 为1或者-1，说明高度变了，要继续更新父结点以及组织结点的BF
                else if (parent->bf == 1 || parent->_bf == -1)
                {
                        parent = parent->_parent;
                        cur = cur->_parent;
                }
                //已经不平衡了 进行旋转处理。
                else if (parent->bf == 2 || parent->_bf == -2)
                {
                        //旋转处理
                }
                // 如果出现其他情况，说明插入之前这棵树就不是AVL树
                else
                {
                        cout << "插入前不是AVL树" << endl;
                }
        }
        return true;
}

最小不平衡子树

在进行旋转之前，先认识一下最小不平衡子树。

距离插入结点最近，且平衡因子绝对值大于1 的结点为根节点，称之为最小不平衡子树。比如下面新插入节点37，距离它最近平衡因子绝对值大于1的节点为58。以58为根节点称之为最小不平衡子树。
image.png

旋转

旋转的目的就是为了降低树的高度，让这棵树平衡成为AVL树
旋转一共有四种情况，分别是左单旋，右单旋，左右双旋，右左双旋。
下面一一介绍这四种情况

1. 左单旋(逆时针旋转)
当插入节点在右子树的右侧。
比如对下面抽象图进行插入结点（图中a、b、c、x、y都是高度为h的AVL树）

image.png

image.png

插入结点在右子树的右侧，此时以30为根结点称之为最小不平衡子树。需要对这颗最小不平衡子树进行左单旋处理 从而降低整棵树的高度，让继续成为AVL树。

注意： 这里虽然整颗树的根节点20的平衡因子也受到了影响，但是旋转是只用处理最小不平衡子树即可。不用

image.png

左单旋处理完之后，整颗树整棵树的仍然是AVL树

image.png

如何左单旋？

image.png
对上面一些关键结点进行命名。方便后续处理

  • 让最小不平衡子树的subRL结点作为parent结点的右子树
  • 让这颗最小不平衡子树的parnet做为subR的左子树
  • 让subR做为这颗最小不平衡子树的根节点
  • 最后更新平衡因子

代码实现：

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

        //让subRL结点作为parent结点的右子树 更新完之后处理subRL_parent;
        parent->_right = subRL;
        if (subRL != nullptr)
        {
                subRL->_parent = parent;
        }

        //让parnet做为subR的左子树 更新完之后处理parent的_parent
        subR->_left = parent;
        parent->_parent = subR;

        //subR做为这颗最小不平衡子树的根节点
        if (parent_parent == nullptr)
        {
                _root = subR;
                _root->_parent = nullptr;
        }
        else
        {
                if (parent_parent->_left == parent)
                {
                        parent_parent->_left = subR;
                }
                else
                {
                        parent_parent->_right = subR;
                }
                subR->_parent = parent_parent;
        }

        //更新平衡因子
        parent->_bf = subR->_bf = 0;
}

2. 右单旋(顺时针旋转)
当新插入节点在左子树的左侧。
比如对下面AVL树左子树左侧中插入新节点
image.png
此时以60为根节点为最下不平衡子树。
需要对这颗最小不平衡子树进行右单旋处理，从而降低整颗A树的高度，让继续成为AVL树。

image.png
右单旋之后，整颗树仍然是AVL树

image.png
如何右单旋？

image.png

对上面一些关键结点进行命名。方便后续处理

  • 让这颗最小不平衡子树的subLR节点做为parent节点的左子树
  • 让这颗最小不平衡子树的parent节点做为subL的右子树
  • 让subL做为整颗最小不平衡子树的根节点
  • 更新平衡因子
    代码实现：
void RotateR(Node* parent)
{
    Node* subL = parent->_left;
    Node* subLR = subL->_right;
    Node* parent_parent = parent->_parent;

    //让subLR节点做为parent节点的左子树 更新完之后处理subLR的_parent;
    parent->_left = subLR;
    if (subLR != nullptr)
    {
            subLR->_parent = parent;
    }

    //让parent节点做为subL的右子树 更新完之后处理parent的_parent
    subL->_right = parent; 
    parent->_parent = subL;

    //让这颗最小不平衡子树的parent节点做为subL的右子树
    if (parent_parent == nullptr)
    {
            _root = subL;
            subL->_parent = nullptr;
    }
    else
    {
            if (parent_parent->_left == parent)
            {
                    parent_parent->_left = subL;
            }
            else
            {
                    parent_parent->_right = subL;
            }
            subL->_parent = parent_parent;
    }

    //更新平衡因子
    parent->_bf = subL->_bf = 0;
}

3. 左右双旋
新节点插入在较高左子树的右侧：先左单旋再右单旋
比如对下面AVL树插入一个新节点。

image.png
注意：：这里较高左子树值指的是结点30。如果新节点插入在c树(不论左右)也会引发旋转。这里以新节点插入在b树下为例。

此时以90为根节点的称为最小不平衡子树。这种情况就需要对这棵树进行左右双旋处理，降低整颗树的高度，从而让这颗树继续成为AVL树。

先以最小不平衡子树的根节点左子树做为根进行左单旋：

  • 让最小不平衡子树的subRL结点作为parent结点的右子树
  • 让这颗最小不平衡子树的parnet做为subR的左子树
  • 让subR做为这颗最小不平衡子树的根节点
  • 最后更新平衡因子
    image.png

再以最小不平衡子树的根节点做为根进行右单旋

  • 让这颗最小不平衡子树的subLR节点做为parent节点的左子树
  • 让这颗最小不平衡子树的parent节点做为subL的右子树
  • 让subL做为整颗最小不平衡子树的根节点
  • 更新平衡因子

image.png

双旋转完之后，整颗树变为下面这种情况。达到了旋转的目的。

image.png

注意：: 双旋完之后，要更新平衡因子。如何更新：

  • 当新节点在b树下:
    subLR双旋转前的bf为-1，双旋之后变为0，subL的bf变为0，parent的bf变为1
    image.png
  • 当新节点在c树下
    subLR双旋转前的bf为1，双旋之后变为0，subL的bf变为-1，parent的bf变为0
    image.png
  • 当60就是新插入节点
    subLR双旋转前的bf为0，双旋之后变为0，subL的bf变为0，parent的bf变为0
    image.png

代码实现：

void RotateLR(Node* parent)
{
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        int bf = subLR->_bf;
        //左单旋
        RotateL(parent->_left);
        //右单旋
        RotateR(parent);
        //更新平衡因子
        if (bf == 1)
        {
                parent->_bf = 0;
                subLR->_bf = 0;
                subL->_bf = -1;
        }
        else if(bf == -1)
        {
                parent->_bf = 1;
                subLR->_bf = 0;
                subL->_bf = 0;
        }
        else if (bf == 0)
        {
                parent->_bf = 0;
                subLR->_bf = 0;
                subL->_bf = 0;
        }
        else
        {
                assert(false);
        }
}

4. 右左双旋
新节点插入较高右子树的左侧：先右单旋再左单旋
比如对下面AVL树插入一个新节点：

image.png
注意： 这里较高右子树指的是90，如果新节点插入在b树(不论左右)也会引发旋转。这里以新节点插入在c树下为例。

此时以30为根节点称为最小不平衡子树。这种情况就需要对这颗子树进行旋转处理，降低整棵树的高度，让继续成为AVL树。

先让最小不平衡子树根节点的右子树90做为根节点进行右单旋

  • 让这颗最小不平衡子树的subLR节点做为parent节点的左子树
  • 让这颗最小不平衡子树的parent节点做为subL的右子树
  • 让subL做为整颗最小不平衡子树的根节点
  • 更新平衡因子

image.png
再以最小不平衡子树的根节点做为根进行左单旋

  • 让最小不平衡子树的subRL结点作为parent结点的右子树
  • 让这颗最小不平衡子树的parnet做为subR的左子树
  • 让subR做为这颗最小不平衡子树的根节点
  • 最后更新平衡因子

image.png
双旋完之后，整颗树变为下面这种情况：

image.png
注意： 这里和左右双旋一样，要更新BF。

  • 当新节点在c树下
    subRL双旋之前bf为1，双旋之后，subRL的平衡因子变为0，parent的平衡因子变为-1，subR的平衡因子变为0
    image.png
  • 当新节点在b树下
    subRL双旋之前bf为-1，双旋之后，subRL的平衡因子变为0，parent的平衡因子变为0，subR的平衡因子变为1
    image.png
  • 当60就是新节点
    subRL双旋之前bf为0，双旋之后，subRL的平衡因子变为0，parent的平衡因子变为0，subR的平衡因子变为0
    image.png
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);
        }
}

关于旋转的逻辑全部写完，下面就是什么什么时候要进行左单旋，什么时候要右单旋，以及什么时候双旋
通过上面画的图可以看出：

  • 当平衡因子都为正的时候，需要进行左单旋，
  • 当平衡因子都为负的时候，需要进行右单旋。
  • 当父结点的平衡因子为父且当前节点平衡因子为正时，需要进行左右双旋，先左单旋，让平衡因子都为负，再进行右单旋，从而达到旋转的目的
  • 当父结点的平衡因子为正，当前节点的平衡因子为负的时候，需要进行右左双。先右单旋，让平衡因子都为正，再进行左单旋，从而达到旋转的目的

注意： 要旋转时的父节点的平衡因子只能为2或-2，当前节点的平衡因子只能为1或-1。如果出现别的情况，说明插入前这棵树就不是AVL树。

整个插入代码为

bool insert(const pair<K, V>& kv)
{
        //空树，直接作为根节点
        if (_root == nullptr)
        {
                _root = new Node(kv);
                return true;
        }

        //按照二叉搜索树的插入进行插入
        Node* cur = _root;
        Node* parent = nullptr;
        //确定插入结点的位值
        while (cur)
        {
                if ((kv.first) < (cur->_kv.first))//待插入结点Key小于当前结点的Key
                {
                        parent = cur;
                        cur = cur->_left;
                }
                else if ((kv.first) > (cur->_kv.first))
                {
                        parent = cur;
                        cur = cur->_right;
                }
                else//Key值冗余 不允许插入
                {
                        return false;
                }
        }

        //链接 
        cur = new Node(kv);
        //确定插入结点的位置，在父结点的左边还是右边
        if (kv.first < parent->_kv.first)
        {
                parent->_left = cur;
        }
        else
        {
                parent->_right = cur;
        }
        cur->_parent = parent;


        //调整平衡因子
        while (parent != nullptr)
        {
                //插入到右子树中将BF++
                if (cur == parent->_right)
                {
                        parent->_bf++;
                }
                //插入到左子树中 将BF--
                else
                {
                        parent->_bf--;
                }

                //BF为0 说明已经平衡 无需处理
                if (parent->_bf == 0)
                {
                        break;
                }
                // BF 为1或者-1，说明高度变了，要继续更新父结点以及组织结点的BF
                else if (parent->_bf == 1 || parent->_bf == -1)
                {
                        parent = parent->_parent;
                        cur = cur->_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)
                        {
                                //右单旋
                                RotateR(parent);
                        }
                        else if (parent->_bf == -2 && cur->_bf == 1)
                        {
                                //左右双旋
                                RotateLR(parent);
                        }
                        else if (parent->_bf == 2 && cur->_bf == -1)
                        {
                                //右左双旋
                                RotateRL(parent);
                        }
                        else
                        {
                                assert(false);
                        }
                        break;
                }
                // 如果出现其他情况，说明插入之前这棵树就不是AVL树
                else
                {
                        assert(false);
                }
        }
        return true;
}

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

        //让subRL结点作为parent结点的右子树 更新完之后处理subRL_parent;
        parent->_right = subRL;
        if (subRL != nullptr)
        {
                subRL->_parent = parent;
        }

        //让parnet做为subR的左子树 更新完之后处理parent的_parent
        subR->_left = parent;
        parent->_parent = subR;

        //subR做为这颗最小不平衡子树的根节点
        if (parent_parent == nullptr)
        {
                _root = subR;
                _root->_parent = nullptr;
        }
        else
        {
                if (parent_parent->_left == parent)
                {
                        parent_parent->_left = subR;
                }
                else
                {
                        parent_parent->_right = subR;
                }
                subR->_parent = parent_parent;
        }

        //更新平衡因子
        parent->_bf = subR->_bf = 0;
}

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

        //让subLR节点做为parent节点的左子树 更新完之后处理subLR的_parent;
        parent->_left = subLR;
        if (subLR != nullptr)
        {
                subLR->_parent = parent;
        }

        //让parent节点做为subL的右子树 更新完之后处理parent的_parent
        subL->_right = parent; 
        parent->_parent = subL;

        //让这颗最小不平衡子树的parent节点做为subL的右子树
        if (parent_parent == nullptr)
        {
                _root = subL;
                subL->_parent = nullptr;
        }
        else
        {
                if (parent_parent->_left == parent)
                {
                        parent_parent->_left = subL;
                }
                else
                {
                        parent_parent->_right = subL;
                }
                subL->_parent = parent_parent;
        }

        //更新平衡因子
        parent->_bf = subL->_bf = 0;
}
void RotateLR(Node* parent)
{
        Node* subL = parent->_left;
        Node* subLR = subL->_right; //subLR不可能为nullptr，因为subL的平衡因子是1
        int bf = subLR->_bf;  // 记录平衡因子
        //以最小不平衡子树的左结点进行左单旋
        RotateL(parent->_left);
        //右单旋
        RotateR(parent);

        //更新平衡因子
        if (bf == 1)//对应插入再C树下
        {
                parent->_bf = 0;
                subLR->_bf = 0;
                subL->_bf = -1;
        }
        else if(bf == -1)//对应插入再b树下
        {
                parent->_bf = 1;
                subLR->_bf = 0;
                subL->_bf = 0;
        }
        else if (bf == 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)//对应插入再c树下
        {
                subR->_bf = 0;
                parent->_bf = -1;
                subRL->_bf = 0;
        }
        else if (bf == -1)//对应插入再b树下
        {		
                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);
        }
}

AVL树的验证

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

  • 验证其为二叉搜索树
    • 如果中序遍历可得到一个有序的序列，就说明为二叉搜索树
void Inorder()
{
    _Inorder(_root);
    cout << endl;
}
void _Inorder(Node* root)
{
    if (nullptr == root)
    {
            return;
    }
    _Inorder(root->_left);
    cout << root->_kv.first << ' ';
    _Inorder(root->_right);
}
  • 验证其为平衡树
    • 从叶子结点处开始计算每棵子树的高度。（每棵子树的高度 = 左右子树中高度的较大值 + 1）
    • 分别判断左右子树的高度
    • 若左右子树均为平衡二叉树，则返回当前子树的高度给上一层，继续判断上一层的子树是否是平衡二叉树，直到判断到根为止。
bool isAVLTree()
{
        int hight = 0;
        return _IsBalanced(_root, hight);
}
bool _IsBalanced(Node* root, int& hight)
{
        //空树也是AVL树
        if (nullptr == root)
        {
                hight = 0;
                return true;
        }
        //判断左子树
        int leftHight = 0;
        if (!(_IsBalanced(root->_left, leftHight)))
        {
                return false;
        }
        //判断右子树
        int rightHight = 0;
        if (!(_IsBalanced(root->_right, rightHight)))
        {
                return false;
        }
        //检查该节点的平衡因子
        if (rightHight - leftHight != root->_bf)
        {
                cout << "平衡因子设置异常：" << root->_kv.first << endl;
        }
        hight = max(leftHight, rightHight) + 1;

        return abs(rightHight - leftHight) < 2;
}

参考源码

  • gitee AVL树
  • 菜鸟一枚，写的不好的地方请各位大佬多多包涵，手下留情。
C++下等马
关注
专栏目录
AVL.rar_AVL树
09-21
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL树，AV是两位发明者姓名的首字母。这种数据结构在进行插入和删除操作后能自动调整...
STL set
hls0611的博客
11-09 254
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 264
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
2411C++,C++26反射示例
个人进步之路
11-13 661
2411C++,C++26反射示例
C++——智能指针
Wangx_wang的博客
11-12 761
介绍了几种智能指针的不同和实现思路以及循环引用的问题
C++builder中的人工智能（15）：C++高斯误差线性单元（GELU）
caridle的专栏
11-08 718
激活函数（phi()），也称为转移函数或阈值函数，它根据净输入函数的给定值（sum）确定激活值（a = phi(sum)）。在这里，sum是它们权重中的信号之和，激活函数是这个和的新值，具有给定的函数或条件。换句话说，激活函数是将所有加权信号的和转换为该信号的新激活值的方法。有不同类型的激活函数，通常使用的是线性（恒等）、双极性和逻辑（sigmoid）函数。在C++（以及大多数编程语言）中，你可以创建自己的激活函数。注意，sum是净输入函数的结果，它计算所有加权信号的和。我们将使用这些作为输入函数的结果。
C++ 内存分布及 new , delete 分配问题( ~~~ 面试重要 ~~~)
GAOSHOUCYUYAN的博客
11-10 776
本篇文章笔者将会对 C++ 中的内存问题简单的讲解 , 同时对 new , delete 的面试题进行重点讲解.以上就是本篇的内容 , 希望读者认真领会.
快速上手STL中list的使用
最新发布
知其然 知其所以然
11-13 404
【代码】快速上手STL中list的使用。
c语言基础知识点（十五）C语言中的指针+1与指针的二进制表示+1的区别
qq_51519091的博客
11-13 145
给一个指针加上一个整数与给该指针的二进制表示加上同样的整数，这两者之间存在本质的区别，主要体现在操作对象、操作意义以及结果上。
C++初阶——list
qq_55890817的博客
11-12 673
list是一个可以在序列的任意位置进行插入和删除的容器，并且可以进行双向迭代。list的底层是一个双向链表，双向链表可以将它们包含的每个元素存储在不同且不相关的存储位置。通过将每个元素与前一个元素的链接和后一个元素的链接关联起来，内部保持了顺序。
扫雷游戏代码分享(c基础)
lb3636363636的博客
11-11 1610
创建两个.c 一个.h。
探索 C++20：C++ 的新纪元
2404_88048702的博客
11-09 1252
C++20 为开发者带来了一系列激动人心的新特性，这些特性不仅改善了编程体验，而且打开了新的可能性的大门。无论您是通过使用概念提升模板编程的安全性，或是利用协程简化异步操作，C++20 都将助您一臂之力。C++20 的未来无疑是光明的，让我们继续探索和实践，释放这一强大语言的全部潜力。祝大家在 C++20 中编写出更高效、更优雅的代码！
c++ 分治算法
www_dong的博客
11-08 856
分治算法是一种重要的算法设计范式，其核心思想是将一个复杂的问题分解为多个规模较小的相同问题，逐步解决这些较小的问题，最后将这些问题的解合并成原问题的解。
C++ 的协程
Leo@Apas
11-13 321
协程函数使用co_awaitco_yield（对于生成器）或co_return来控制其执行流程。下面是一个简单的例子，展示了如何使用co_await来挂起和恢复协程的执行。// 一个简单的awaitable对象，它会在一段时间后“完成”} // 协程需要挂起void await_suspend(std::coroutine_handle<>) const noexcept {} // 挂起时的操作（这里为空）
【蓝桥等考C++真题】蓝桥杯等级考试C++组第13级L13真题原题(含答案)-成绩排序ABCDE
SunMy的博客
11-12 275
【代码】【蓝桥等考C++真题】蓝桥杯等级考试C++组第13级L13真题原题(含答案)-成绩排序ABCDE。
c++：string（一）
jjj_mmm的博客
11-13 563
三种遍历方法，[],迭代器，范围for范围for底层是迭代器，所以只有容器中支持迭代器的才支持范围for因为数组底层和迭代器差不多，所以也支持范围forauto是一个自动识别的类型，在定义迭代器类型一般是很多的字母，可以用auto。
探索C++文字加密：保护信息的无懈可击之道
SYC20110120的博客
11-10 175
凯撒密码是一种简单的替换密码，将字母按照一定的位移进行替换。在示例中，明文为"hello world"，位移为3，加密后的文本为"khoor zruog"，解密后的文本为"hello world"。
C语言中操作符详解(中)
2301_80667728的博客
11-13 491
(C语言中 关系操作符、逻辑操作符 、短路特性 等详解)
AVL树基础操作与逻辑功能实现
资源摘要信息:"AVL树的操作实现与概念介绍" 知识点详细说明: 1. AVL树的定义与特性: AVL树是一种自平衡的二叉搜索树，由苏联计算机科学家G.M. Adelson-Velsky和E.M. Landis在1962年提出。AVL树的特点是任何节点的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

C++下等马

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值