C++ AVL树实现详解

最新推荐文章于 2025-12-20 15:00:56 发布
原创 最新推荐文章于 2025-12-20 15:00:56 发布 · 839 阅读 · 23 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

1. AVL树的概念与原理

AVL树是最早发明的自平衡二叉查找树，由前苏联科学家G. M. Adelson-Velsky和E. M. Landis在1962年的论文《An algorithm for the organization of information》中提出。AVL树得名于两位发明者的姓氏首字母。

1.1 AVL树的定义

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

  1. 它的左右子树都是AVL树
  2. 左右子树的高度差的绝对值不超过1

AVL树通过严格控制高度差来维持平衡，是一种高度平衡的二叉搜索树。

1.2 平衡因子

在AVL树的实现中，我们引入平衡因子(Balance Factor)的概念：

  • 每个节点都有一个平衡因子
  • 平衡因子 = 右子树高度 - 左子树高度
  • 合法平衡因子值：-1, 0, 1

平衡因子虽然并非AVL树必须的，但它能直观地反映树的平衡状态，便于我们观察和控制树的平衡性。

1.3 为什么高度差不超过1？

初学者可能会问：为什么不要求高度差为0，这样不是更平衡吗？通过分析可以发现：

  1. 在某些情况下（如节点数为2、4等），无法做到高度差为0
  2. 允许1的高度差可以在平衡性和实现复杂度之间取得良好平衡

1.4 AVL树的性能

AVL树的节点分布与完全二叉树类似，高度始终控制在O(logN)，因此其增删查改操作的时间复杂度都能保证在O(logN)，相比普通二叉搜索树有本质提升。
在这里插入图片描述
在这里插入图片描述

2. AVL树的实现

2.1 AVL树的结构

template<class K, class V>
struct AVLTreeNode {
    pair<K, V> _kv;
    AVLTreeNode<K, V>* _left;
    AVLTreeNode<K, V>* _right;
    AVLTreeNode<K, V>* _parent;  // 需要parent指针来更新平衡因子
    int _bf;  // balance factor

    AVLTreeNode(const pair<K, V>& kv)
        :_kv(kv)
        , _left(nullptr)
        , _right(nullptr)
        , _parent(nullptr)
        , _bf(0)
    {}
};

template<class K, class V>
class AVLTree {
    typedef AVLTreeNode<K, V> Node;
public:
    // 接口函数
private:
    Node* _root = nullptr;
};

2.2 AVL树的插入操作

插入操作分为几个关键步骤：

  1. 按二叉搜索树规则插入新节点
  2. 更新平衡因子：从新节点向上更新到根节点路径上的平衡因子
  3. 检查平衡性：如果发现不平衡，进行旋转调整
  4. 旋转调整：通过旋转恢复平衡，同时降低子树高度
2.2.1 平衡因子更新规则
  • 平衡因子 = 右子树高度 - 左子树高度
  • 只有子树高度变化才会影响当前节点的平衡因子
  • 插入节点后平衡因子更新：
    • 新节点在父节点右子树：父节点平衡因子++
    • 新节点在父节点左子树：父节点平衡因子–
2.2.2 更新停止条件
  1. 平衡因子变为0：说明原本一边高一边低的子树现在两边高度相同，子树高度不变，更新结束
  2. 平衡因子变为1或-1：说明原本平衡的子树现在一边高一边低，子树高度增加1，需要继续向上更新
  3. 平衡因子变为2或-2：说明子树已不平衡，需要进行旋转调整，旋转后更新结束
  • 更新到10结点，平衡因子为2，10所在的子树已经不平衡，需要旋转处理
    在这里插入图片描述
  • 更新到中间结点，3为根的子树高度不变，不会影响上一层，更新结束
    在这里插入图片描述
  • 最坏更新到根停止
    在这里插入图片描述
2.2.3 插入实现代码
bool Insert(const pair<K, V>& kv) {
    if (_root == nullptr) {
        _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;
        }
    }

    cur = new Node(kv);
    if (parent->_kv.first < kv.first) {
        parent->_right = cur;
    }
    else {
        parent->_left = cur;
    }
    cur->_parent = parent;

    // 更新平衡因子
    while (parent) {
        if (cur == parent->_left) {
            parent->_bf--;
        }
        else {
            parent->_bf++;
        }

        if (parent->_bf == 0) {
            break;
        }
        else if (parent->_bf == 1 || parent->_bf == -1) {
            cur = parent;
            parent = parent->_parent;
        }
        else if (parent->_bf == 2 || parent->_bf == -2) {
            // 不平衡，需要旋转处理
            // ...旋转代码将在下面介绍
            break;
        }
        else {
            assert(false);
        }
    }
    return true;
}

2.3 旋转操作

当树失去平衡时，需要通过旋转来恢复平衡。旋转操作有四种基本类型：

2.3.1 旋转原则
  1. 保持二叉搜索树的性质不变
  2. 使不平衡的树恢复平衡
  3. 降低旋转子树的高度
2.3.2 右单旋

适用场景：左子树过高（平衡因子为-2），且左子树的左子树较高（左子树的平衡因子为-1）

操作步骤：

  1. 将父节点的左子节点提升为新根
  2. 将新根的右子树作为原父节点的左子树
  3. 将原父节点作为新根的右子树
  • 简记：右单旋就是把右边压下去（对照图理解，左单旋同理）
    在这里插入图片描述
void RotateR(Node* parent) {
    Node* subL = parent->_left;
    Node* subLR = subL->_right;

    parent->_left = subLR;
    if (subLR) subLR->_parent = parent;

    Node* parentParent = parent->_parent;
    subL->_right = parent;
    parent->_parent = subL;

    if (parentParent == nullptr) {
        _root = subL;
        subL->_parent = nullptr;
    }
    else {
        if (parent == parentParent->_left) {
            parentParent->_left = subL;
        }
        else {
            parentParent->_right = subL;
        }
        subL->_parent = parentParent;
    }
    parent->_bf = subL->_bf = 0;
}
2.3.3 左单旋

适用场景：右子树过高（平衡因子为2），且右子树的右子树较高（右子树的平衡因子为1）

操作步骤：

  1. 将父节点的右子节点提升为新根
  2. 将新根的左子树作为原父节点的右子树
  3. 将原父节点作为新根的左子树
    在这里插入图片描述
void RotateL(Node* parent) {
    Node* subR = parent->_right;
    Node* subRL = subR->_left;

    parent->_right = subRL;
    if (subRL) subRL->_parent = parent;

    Node* parentParent = parent->_parent;
    subR->_left = parent;
    parent->_parent = subR;

    if (parentParent == nullptr) {
        _root = subR;
        subR->_parent = nullptr;
    }
    else {
        if (parent == parentParent->_left) {
            parentParent->_left = subR;
        }
        else {
            parentParent->_right = subR;
        }
        subR->_parent = parentParent;
    }
    parent->_bf = subR->_bf = 0;
}
2.3.4 左右双旋

适用场景：左子树过高（平衡因子为-2），且左子树的右子树较高（左子树的平衡因子为1）

操作步骤：

  1. 先对左子节点进行左旋
  2. 再对父节点进行右旋
  3. 三个场景如图
    在这里插入图片描述
void RotateLR(Node* parent) {
    Node* subL = parent->_left;
    Node* subLR = subL->_right;
    int bf = subLR->_bf;

    RotateL(parent->_left);
    RotateR(parent);

    // 根据subLR原来的平衡因子调整各节点平衡因子
    if (bf == 0) {
        subL->_bf = 0;
        subLR->_bf = 0;
        parent->_bf = 0;
    }
    else if (bf == -1) {
        subL->_bf = 0;
        subLR->_bf = 0;
        parent->_bf = 1;
    }
    else if (bf == 1) {
        subL->_bf = -1;
        subLR->_bf = 0;
        parent->_bf = 0;
    }
    else {
        assert(false);
    }
}
2.3.5 右左双旋

适用场景：右子树过高（平衡因子为2），且右子树的左子树较高（右子树的平衡因子为-1）

操作步骤：

  1. 先对右子节点进行右旋
  2. 再对父节点进行左旋
  3. 同上
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) {
        subR->_bf = 0;
        subRL->_bf = 0;
        parent->_bf = 0;
    }
    else if (bf == 1) {
        subR->_bf = 0;
        subRL->_bf = 0;
        parent->_bf = -1;
    }
    else if (bf == -1) {
        subR->_bf = 1;
        subRL->_bf = 0;
        parent->_bf = 0;
    }
    else {
        assert(false);
    }
}

2.4 AVL树的查找

查找操作与普通二叉搜索树相同，时间复杂度为O(logN)：

Node* Find(const K& key) {
    Node* cur = _root;
    while (cur) {
        if (cur->_kv.first < key) {
            cur = cur->_right;
        }
        else if (cur->_kv.first > key) {
            cur = cur->_left;
        }
        else {
            return cur;
        }
    }
    return nullptr;
}

2.5 AVL树的平衡检测

为了验证AVL树的实现是否正确，我们可以通过检查每个节点的平衡因子和子树高度差来进行验证：

int _Height(Node* root) {
    if (root == nullptr) return 0;
    int leftHeight = _Height(root->_left);
    int rightHeight = _Height(root->_right);
    return max(leftHeight, rightHeight) + 1;
}

bool _IsBalanceTree(Node* root) {
    if (root == nullptr) return true;
    
    int leftHeight = _Height(root->_left);
    int rightHeight = _Height(root->_right);
    int diff = rightHeight - leftHeight;
    
    if (abs(diff) >= 2) {
        cout << root->_kv.first << "高度差异常" << endl;
        return false;
    }
    if (root->_bf != diff) {
        cout << root->_kv.first << "平衡因子异常" << endl;
        return false;
    }
    
    return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
}

3.总代码实现

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;

namespace sty {
    // AVL树节点结构体
    template<class K, class V>
    struct AVLTreeNode {
        pair<K, V> _kv;                  // 键值对
        AVLTreeNode<K, V>* _left;         // 左子节点
        AVLTreeNode<K, V>* _right;        // 右子节点
        AVLTreeNode<K, V>* _parent;       // 父节点指针（用于平衡因子更新）
        int _bf;                         // 平衡因子(balance factor)

        // 构造函数
        AVLTreeNode(const pair<K, V>& kv)
            :_kv(kv)
            , _left(nullptr)
            , _right(nullptr)
            , _parent(nullptr)
            , _bf(0)
        {}
    };

    // AVL树类
    template<class K, class V>
    class AVLTree {
        typedef AVLTreeNode<K, V> Node;
    public:
        // 插入键值对
        bool Insert(const pair<K, V>& kv) {
            // 如果树为空，直接创建根节点
            if (_root == nullptr) {
                _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;
                }
            }

            // 创建新节点并插入
            cur = new Node(kv);
            if (parent->_kv.first < kv.first) {
                parent->_right = cur;
            }
            else {
                parent->_left = cur;
            }
            cur->_parent = parent;

            // 更新平衡因子
            while (parent) {
                // 根据插入位置更新父节点的平衡因子
                if (cur == parent->_left)
                    parent->_bf--;  // 插入在左子树，平衡因子减1
                else
                    parent->_bf++;  // 插入在右子树，平衡因子加1

                // 根据更新后的平衡因子决定下一步操作
                if (parent->_bf == 0) {
                    // 平衡因子为0，说明子树高度不变，更新结束
                    break;
                }
                else if (parent->_bf == 1 || parent->_bf == -1) {
                    // 平衡因子为1或-1，说明子树高度变化，需要继续向上更新
                    cur = parent;
                    parent = parent->_parent;
                }
                else if (parent->_bf == 2 || parent->_bf == -2) {
                    // 平衡因子为2或-2，需要进行旋转调整
                    if (parent->_bf == -2 && cur->_bf == -1) {
                        // 左左情况 - 右单旋
                        RotateR(parent);
                    }
                    else if (parent->_bf == 2 && cur->_bf == 1) {
                        // 右右情况 - 左单旋
                        RotateL(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;  // 旋转后子树高度恢复，更新结束
                }
                else {
                    assert(false);  // 平衡因子异常
                }
            }
            return true;
        }

        // 右单旋（处理左左不平衡情况）
        void RotateR(Node* parent) {
            Node* subL = parent->_left;    // parent的左孩子
            Node* subLR = subL->_right;    // subL的右孩子

            // 将subLR作为parent的左孩子
            parent->_left = subLR;
            if (subLR)
                subLR->_parent = parent;

            Node* pParent = parent->_parent;  // parent的父节点

            // 将parent作为subL的右孩子
            subL->_right = parent;
            parent->_parent = subL;

            // 处理旋转后的根节点连接
            if (parent == _root) {
                _root = subL;
                subL->_parent = nullptr;
            }
            else {
                if (pParent->_left == parent) {
                    pParent->_left = subL;
                }
                else {
                    pParent->_right = subL;
                }
                subL->_parent = pParent;
            }

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

        // 左单旋（处理右右不平衡情况）
        void RotateL(Node* parent) {
            Node* subR = parent->_right;   // parent的右孩子
            Node* subRL = subR->_left;     // subR的左孩子

            // 将subRL作为parent的右孩子
            parent->_right = subRL;
            if (subRL)
                subRL->_parent = parent;

            Node* parentParent = parent->_parent;  // parent的父节点

            // 将parent作为subR的左孩子
            subR->_left = parent;
            parent->_parent = subR;

            // 处理旋转后的根节点连接
            if (parentParent == nullptr) {
                _root = subR;
                subR->_parent = nullptr;
            }
            else {
                if (parent == parentParent->_left) {
                    parentParent->_left = subR;
                }
                else {
                    parentParent->_right = subR;
                }
                subR->_parent = parentParent;
            }

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

        // 左右双旋（处理左右不平衡情况）
        void RotateLR(Node* parent) {
            Node* subL = parent->_left;
            Node* subLR = subL->_right;
            int bf = subLR->_bf;  // 保存旋转前的平衡因子

            // 先对subL进行左旋，再对parent进行右旋
            RotateL(parent->_left);
            RotateR(parent);

            // 根据subLR原来的平衡因子调整各节点平衡因子
            if (bf == -1) {  // 新节点插入在subLR的左子树
                subLR->_bf = 0;
                subL->_bf = 0;
                parent->_bf = 1;
            }
            else if (bf == 1) {  // 新节点插入在subLR的右子树
                subLR->_bf = 0;
                subL->_bf = -1;
                parent->_bf = 0;
            }
            else if (bf == 0) {  // subLR本身就是新节点
                subLR->_bf = 0;
                subL->_bf = 0;
                parent->_bf = 0;
            }
            else {
                assert(false);  // 不应该出现的情况
            }
        }

        // 右左双旋（处理右左不平衡情况）
        void RotateRL(Node* parent) {
            Node* subR = parent->_right;
            Node* subRL = subR->_left;
            int bf = subRL->_bf;  // 保存旋转前的平衡因子

            // 先对subR进行右旋，再对parent进行左旋
            RotateR(parent->_right);
            RotateL(parent);

            // 根据subRL原来的平衡因子调整各节点平衡因子
            if (bf == 0) {  // subRL本身就是新节点
                subR->_bf = 0;
                subRL->_bf = 0;
                parent->_bf = 0;
            }
            else if (bf == 1) {  // 新节点插入在subRL的右子树
                subR->_bf = 0;
                subRL->_bf = 0;
                parent->_bf = -1;
            }
            else if (bf == -1) {  // 新节点插入在subRL的左子树
                subR->_bf = 1;
                subRL->_bf = 0;
                parent->_bf = 0;
            }
            else {
                assert(false);  // 不应该出现的情况
            }
        }

        // 中序遍历
        void InOrder() {
            _InOrder(_root);
            cout << endl;
        }

        // 获取树的高度
        int Height() {
            return _Height(_root);
        }

        // 获取树的节点数量
        int Size() {
            return _Size(_root);
        }

        // 检查树是否平衡
        bool IsBalanceTree() {
            return _IsBalanceTree(_root);
        }

        // 查找键为key的节点
        Node* Find(const K& key) {
            Node* cur = _root;
            while (cur) {
                if (cur->_kv.first < key) {
                    cur = cur->_right;
                }
                else if (cur->_kv.first > key) {
                    cur = cur->_left;
                }
                else {
                    return cur;
                }
            }
            return nullptr;
        }

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

        // 递归计算树的高度
        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;
        }

        // 递归计算树的节点数量
        int _Size(Node* root) {
            if (root == nullptr)
                return 0;
            return _Size(root->_left) + _Size(root->_right) + 1;
        }

        // 递归检查树是否平衡
        bool _IsBalanceTree(Node* root) {
            // 空树是平衡的
            if (nullptr == root)
                return true;
            
            // 计算当前节点的平衡因子（左右子树高度差）
            int leftHeight = _Height(root->_left);
            int rightHeight = _Height(root->_right);
            int diff = rightHeight - leftHeight;

            // 检查平衡因子是否合法
            if (abs(diff) >= 2) {  // 高度差超过1
                cout << root->_kv.first << "高度差异常" << endl;
                return false;
            }

            // 检查存储的平衡因子是否与实际计算的一致
            if (root->_bf != diff) {
                cout << root->_kv.first << "平衡因子异常" << endl;
                return false;
            }

            // 递归检查左右子树
            return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
        }

    private:
        Node* _root = nullptr;  // 根节点
    };
}
C++ AVL树实现详解：理论+代码+图解
铭哥不写bug的博客
08-07 921
本文详细介绍了C++中AVL树的实现原理与代码实现。AVL树是一种自平衡二叉搜索树，通过旋转操作维护平衡因子（左子树高度-右子树高度）在±1之间。文章首先说明AVL树与普通二叉搜索树的区别在于插入和删除时需要额外处理平衡问题，接着详细讲解了插入节点时的平衡因子更新规则和四种旋转情况（LL、RR、LR、RL型），并提供了对应的旋转代码实现。重点强调了旋转操作中节点指针的调整和平衡因子的更新规则，通过图解和代码示例帮助理解AVL树的自平衡机制。
【C++】AVL树详解
muyuteacher的博客
02-29 1486
AVL树是一种高效的自平衡二叉搜索树，在计算机科学领域得到广泛应用。本文主要介绍了AVL树的概念、节点定义、AVL树的实现以及验证，其中包括对平衡因子的解释，研究在插入节点时，如何通过旋转来调节平衡因子来保持AVL树的特性。
【C++】AVL树实现
x_p96484685433的博客
05-11 1677
本文详细介绍了AVL树的概念、实现及其自平衡机制。AVL树是一种自平衡二叉搜索树，通过控制左右子树的高度差来保证查找效率。文章首先介绍了AVL树的基本概念和平衡因子的作用，接着详细讲解了AVL树的插入操作，包括平衡因子的更新和四种旋转操作（右单旋、左单旋、左右双旋、右左双旋）的实现。此外，文章还介绍了AVL树的查找、平衡检测和删除操作，并通过代码示例展示了如何实现这些功能。
C++ AVL树实现详解：平衡二叉搜索树的原理与代码实现
tanyongxi66的博客
07-17 567
AVL树是最早被发明的自平衡二叉查找树，由G. M. Adelson-Velsky和E. M. Landis在1962年的论文中提出。本文将详细介绍AVL树的原理，并通过C++代码实现一个完整的AVL树结构。平衡因子 = 右子树高度 - 左子树高度在AVL树中，每个节点的平衡因子只能是-1、0或1。当插入或删除节点导致平衡因子的绝对值超过1时，就需要通过旋转操作来恢复平衡。// 键值对// 左子节点// 右子节点// 父节点int _bf;// 平衡因子: _kv(kv)
C++ AVL树(详解 完整代码)
SikJ_2020_10_24的博客
03-07 852
{}// 该节点的左孩子// 该节点的右孩子// 该节点的双亲T _data;int _bf;// 该节点的平衡因子。
C++AVL树详解
2401_84541745的博客
09-21 788
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整，即可降低树的高度，从而减少平均搜索长度。一棵AVL。例：2.AVL树的插入AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL。
C++AVL树（二）详解
的博客
01-24 1457
跟左右双旋类似，下面我们将a/b/c子树抽象为高度h的AVL子树进行分析，另外我们需要把b子树的细节进一步展开为12和左子树高度为h-1的e和f子树，因为我们要对b的父亲15为旋转点进行右单旋，右单旋需要动b树中的右子树。b子树中新增结点的位置不同，平衡因子更新的细节也不同，通过观察12的平衡因子不同，这里我们要分三个场景讨论。子树进行分析，另外我们需要把b子树的细节进一步展开为8和左子树高度为h-1的e和f子树，因为。不同，平衡因子更新的细节也不同，通过观察8的平衡因子不同，这里我们要分三个场景讨论。
『 C++ 』AVL树详解 ( 万字 )
小侯宝的博客
01-15 1033
从上文可知,AVL树可以看作是一棵搜索二叉树,其为基于搜索二叉树在此基础上对树做了平衡的操作使其在结构上变得平衡不至于在极端情况下出现"歪脖子树"的情况;AVL树的定义与平衡搜索二叉树的结构上呈现类似;//将节点进行typedefpublic:protected:private://节点指针该篇文章中重点实现AVL树中的插入操作;
C++: AVL树（实现旋转操作）
2301_82256131的博客
03-21 1110
C++: AVL树旋转操作详解
【C++】-- AVL树详解
局部变量和全局变量
08-31 2690
一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： (1)它的左右子树都是AVL树 (2)左右子树高度之差(简称平衡因子=右子树高度-左子树高度)的绝对值不超过1(-1/0/1)
精选资源
基于C++ AVL树的航空客运订票系统【100012693】
06-12
《基于C++ AVL树的航空客运订票系统详解》 航空客运订票系统是现代航空公司运营中的关键组成部分，它能够高效地处理航班信息、预订和退票等业务。本项目以C++编程语言为基础，利用AVL树这一自平衡二叉搜索树的数据...
QtWeatherApp - 简单天气预报软件(C++ Qt6)(附源码)
sweetikelike的博客
12-18 1078
摘要：QtWeatherApp 是一个基于 Qt 6 和 C++ 开发的桌面天气预报应用。该软件通过 OpenWeatherMap Geocoding API 获取城市经纬度，再调用 Open-Meteo 免费天气 API 查询当前天气和7天预报。核心功能包括：支持中英文城市查询、显示温度及天气描述、纯 C++ 实现 Qt 网络请求和 JSON 解析。项目采用模块化设计，包含网络请求、数据处理和 UI 交互组件，可作为学习 Qt 开发的参考案例。软件跨平台支持 Windows/macOS/Linux，源码已
传值还是传引用？c++，python对比
ULTRAmanTAROACE的博客
12-18 529
操作PythonJavaC++传参（基本/不可变）引用（表现如值）值（primitive） / 引用副本（对象）值（拷贝）传参（容器/可变）引用（共享对象）引用副本（可修改内容）值（拷贝整个容器，除非用返回值返回对象引用primitive：值；对象：引用返回值（通常移动或 RVO 优化）赋值 a = ba 绑定到 b 所指对象primitive：值拷贝；对象：引用拷贝深拷贝（调用 operator=）push 到容器存储对象引用存储对象引用拷贝或移动元素（值语义）
【实战】C/C++ 实现 PC 热点（手动开启）+ 手机 UDP 自动发现 + TCP 通信全流程（超详细）
weixin_71604156的博客
12-17 939
本文提出了一种PC与手机本地无线通信的完整解决方案。通过手动开启PC热点、UDP广播自动发现和TCP可靠通信的技术组合，实现了设备间免配置的稳定连接。方案包含详细的技术原理分析、跨平台实现代码（C/C++和Android/Kotlin）以及实际部署指南，解决了传统方案中IP配置复杂、网络依赖强等问题。核心创新点在于解耦热点创建与通信逻辑，采用UDP发现+TCP通信+心跳保活的三重机制，在保证通信可靠性的同时降低了权限要求和实现复杂度。
LeetCode 面试经典 150_回溯_全排列（100_46_C++_中等）
huayimenghan的博客
12-19 788
LeetCode 面试经典 150_回溯_全排列（100_46_C++_中等） 题目描述： 给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
C++ 类与对象：解锁面向对象编程的核心密码（中）
最新发布
emtai486的博客
12-20 770
默认成员函数：构造，析构，拷贝构造，赋值重载，取地址重载
Lua vs C++：核心设计哲学差异——从“系统基石”到“灵活工具”的思维碰撞
羑悻的博客.
12-17 4750
它的每一个特性都需要开发者明确声明意图，编译器会尽可能在编译期捕捉错误（如类型不匹配、未初始化的变量），但对运行时的行为（如内存泄漏、多线程竞争）则交给开发者自己管理。理解两者的设计哲学差异，不仅能帮助你在技术选型时做出更明智的决策，还能让你在不同语言的协作中游刃有余——毕竟，真正的顶尖开发者，从来不是局限于某一种语言，而是能根据问题场景选择最合适的工具。Lua的存在意义是作为“胶水语言”，让主程序（通常是C/C++开发的系统）能够通过脚本快速实现业务逻辑的迭代，而无需重新编译主程序。
C++的左值引用、右值引用以及转发和完美转发
不经一番寒彻骨，怎得梅花扑鼻香。
12-17 676
特性左值引用右值引用符号&&绑定对象左值右值主要用途别名、避免拷贝移动语义、完美转发生命周期与被引用对象相同通常用于临时对象可修改性可以修改原对象可以"偷取"资源理解左值和右值引用对于编写高效的现代C++代码至关重要，特别是在资源管理和模板元编程中。转发是指将函数的参数原封不动地传递给另一个函数，保持参数的原始类型和属性。完美转发是指在模板函数中将参数完全保持其原始类型（左值/右值、const/volatile等）传递给另一个函数。
Google C++ 编码规范核心要点总结 (2025精简版)
猫哥 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS，AIOT)
12-19 1002
本文总结了Google C++编码规范的核心要点，旨在提升代码可读性与一致性。主要包含五大维度：1)头文件与作用域管理，强调自给自足和命名空间使用；2)类设计原则，注重简单明确，推荐组合优先；3)现代C++特性的谨慎使用；4)严格的命名约定，区分不同类型标识符；5)核心编程原则，包括参数传递、类型转换和注释规范。文章强调"显式优于隐式"等核心口诀，并推荐使用cpplint工具进行自动化检测。这些规范适用于需要编写清晰、统一且易于维护的C++代码的开发者。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值