《 C++ 修炼全景指南：十 》自平衡的艺术：深入了解 AVL 树的核心原理与实现

摘要

本文深入探讨了 AVL 树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了 AVL 树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了 AVL 树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。

此外，我们还提供了 AVL 树的遍历方法，包括中序、前序和后序遍历，帮助读者更好地掌握 AVL 树的结构和节点间关系。通过对 AVL 树的优缺点进行分析，本文揭示了其在不同应用场景中的适用性，为读者选择合适的数据结构提供了参考。通过对 AVL 树的全面解析，本文旨在为读者提供一个完整的学习路径，帮助他们掌握这一强大的数据结构。


1、引言

在计算机科学中，数据结构是程序设计的基石，而二叉搜索树 (BST) 则是最基本的树形数据结构之一。二叉搜索树提供了高效的查找、插入和删除操作，但在最坏情况下，这些操作的时间复杂度可能退化为线性。这种退化主要发生在 BST 呈现为链状结构时，例如在顺序插入数据时。因此，为了保证二叉搜索树的性能，出现了多种自平衡树，如红黑树、AVL树、B树等。


关于二叉搜索树的更多细节请见我的这篇博客：《 C++ 修炼全景指南：九 》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧
关于红黑树的更多细节请见我的这篇博客：《 C++ 修炼全景指南：十一 》穿越数据的红与黑：掌握数据平衡的极致艺术


在这些自平衡树中，AVL 树是最早被发明的一种。它由 Adelson-Velsky 和 Landis 于 1962 年提出，因其发明者名字的首字母缩写而得名。AVL 树在插入和删除节点后，通过旋转操作保持树的平衡，从而确保所有操作的时间复杂度始终维持在 O(log⁡n) 。这一特性使得 AVL 树成为实现高效动态集合的一种重要选择。本文将深入探讨AVL树的结构、插入和删除操作的实现，以及其在实际应用中的优缺点。


本篇博客所涉及的所有代码均可从我的代码仓库获得：https://git.lenyiin.com/Lenyiin/AVLTree


2、AVL树概述

AVL 树是一种自平衡二叉搜索树，每个节点都存储一个平衡因子（Balance Factor，简称 BF），用于表示该节点的左子树和右子树的高度差。AVL 树的基本特性是，对于每个节点，要求其左子树和右子树的高度差至多为 1。因此，AVL 树的高度始终保持在 O(log⁡n) ，从而保证查找、插入和删除操作的时间复杂度为 O(log⁡n) 。

2.1、平衡因子

AVL 树中每个节点的平衡因子是该节点右子树的高度减去左子树的高度，即：

​ B F ( n o d e ) = h e i g h t ( r i g h t s u b t r e e ) − h e i g h t ( l e f t s u b t r e e ) BF(node)=height(right subtree)−height(left subtree) BF(node)=height(rightsubtree)−height(leftsubtree)

  • 当平衡因子为 0 时，表示左子树和右子树高度相等。
  • 当平衡因子为正数时，表示右子树比左子树高。
  • 当平衡因子为负数时，表示左子树比右子树高。

AVL树通过限制每个节点的平衡因子在-1、0、1之间，确保树始终保持平衡状态。

2.2、旋转操作

为了保持AVL树的平衡，在插入或删除节点后，如果某个节点的平衡因子超出范围（即绝对值大于1），则需要进行旋转操作来恢复平衡。AVL树主要有四种旋转操作：

  • 单右旋（LL型）：用于修复左子树的左子节点插入导致的不平衡。
  • 单左旋（RR型）：用于修复右子树的右子节点插入导致的不平衡。
  • 先左旋后右旋（LR型）：用于修复左子树的右子节点插入导致的不平衡。
  • 先右旋后左旋（RL型）：用于修复右子树的左子节点插入导致的不平衡。

通过这些旋转操作，AVL树能够在插入和删除节点后迅速恢复平衡，从而保持其高效的操作性能。

2.3、AVL树的应用场景

AVL 树适用于需要频繁查找和插入操作的数据场景，并且对查询操作的效率要求较高。例如，数据库索引、内存中的有序集合、符号表等。虽然 AVL 树在插入和删除操作中需要更多的旋转操作来保持平衡，因此可能不如红黑树等自平衡树高效，但在需要严格平衡以保证查询效率的场景下，AVL 树仍然是一种理想的选择。

2.4、本文的结构

接下来，本文将详细阐述 AVL 树的节点结构、插入与删除操作的具体实现以及旋转操作的原理。随后，我们将对 AVL 树的优缺点进行分析，并探讨其在实际应用中的表现。通过对 AVL 树的全面分析，读者将能够深入理解这一数据结构，并在实际开发中灵活运用。


3、AVL 树的实现

3.1、AVL树节点结构

首先，我们需要定义一个基本的AVL树节点结构。该结构体将包含节点的键值对、左右子节点、父节点，以及用于维护树平衡的平衡因子。平衡因子表示节点右子树高度与左子树高度的差值。

template <class K, class V>
struct AVLTreeNode 
{AVLTreeNode<K, V>* _left;  // 左子节点AVLTreeNode<K, V>* _right; // 右子节点AVLTreeNode<K, V>* _parent; // 父节点int _bf; // 平衡因子 balance factorstd::pair<K, V> _kv; // 键值对// 构造函数AVLTreeNode(const std::pair<K, V>& kv): _left(nullptr), _right(nullptr), _parent(nullptr), _bf(0), _kv(kv) {}
};

详细解释

  • _left：指向左子节点的指针。
  • _right：指向右子节点的指针。
  • _parent：指向父节点的指针，用于在平衡调整时便于向上回溯。
  • _bf：平衡因子，用于判断树是否需要旋转。平衡因子为右子树高度减去左子树高度。
  • _kv：存储节点的键值对。

接下来，我们将基于这个节点结构体，开始AVL树的实现。我们将逐步构建各个功能模块，包括插入、删除、平衡操作等。


3.2、插入操作

插入节点时，首先遵循二叉搜索树的规则进行节点的插入，然后通过调整平衡因子和旋转来维护树的平衡。

bool Insert(const std::pair<K, V>& kv)
{// 1. 先按搜索树的规则进行插入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->_left;}else if (cur->_kv.first < kv.first){parent = cur;cur = cur->_right;}else{return false;	// 如果相等, 表示已经有了, 不需要插入}}// 找到位置cur = new Node(kv);if (parent->_kv.first > kv.first){parent->_left = cur;cur->_parent = parent;}else{parent->_right = cur;cur->_parent = parent;}// 2. 更新平衡因子while (parent){if (cur == parent->_right){parent->_bf++;	// 插在右边, 平衡因子++}else{parent->_bf--;	// 插在左边, 平衡因子--}if (parent->_bf == 0){// 说明 parent 所在的子树高度不变, 更新结束break;}else if (parent->_bf == 1 || parent->_bf == -1){// 说明 parent 所在子树的高度变了, 继续往上更新cur = parent;parent = parent->_parent;}else if (parent->_bf == 2 || parent->_bf == -2){// parent 所在的子树出现问题了, 需要旋转处理一下// 1. 旋转前提是保持它依旧是搜索二叉树// 2. 旋转成平衡树if (parent->_bf == 2){if (cur->_bf == 1){// 左旋RotateL(parent);}else if (cur->_bf == -1){// 右左双旋RotateRL(parent);}}else if (parent->_bf == -2){if (cur->_bf == -1){// 右旋RotateR(parent);}else if (cur->_bf == 1){// 左右双旋RotateLR(parent);}}// 旋转完成后, parent 所在的树的高度恢复到了插入节点前的高度// 如果是子树, 对上一层没有影响, 更新结束break;}}return true;
}

详细解释

  • Insert：插入节点的函数。它根据键值对的大小关系选择插入到左子树还是右子树。

  • _bf 的调整：如果插入在左子树，平衡因子减 1；如果插入在右子树，平衡因子加 1。

  • 插入节点后，我们需要检查树是否仍然平衡。如果树失去平衡（平衡因子的绝对值大于1），就需要执行旋转操作来恢复平衡。

    • RotateL（右子树的右子节点插入）：左单旋
    • RotateR（左子树的左子节点插入）：右单旋
    • RotateRL（右子树的左子节点插入）：右左双旋。
    • RotateLR（左子树的右子节点插入）：先左旋后右旋。

3.3、旋转操作

在 AVL 树中，保持树的平衡性是至关重要的，这主要通过四种旋转操作来实现：左旋、右旋、左-右双旋和右-左双旋。这些旋转操作用于修复因插入或删除节点导致的树不平衡，确保 AVL 树的高度维持在 O(log⁡n) 。下面，我们详细描述这四种旋转方式。

3.3.1、左单旋

场景：当新节点插入到某个节点的右子树的右子节点时，可能导致该节点失衡。此时，需要进行单左旋操作来恢复平衡。

旋转过程：

  • 假设不平衡节点为 A，其右子节点为 B。
  • B 的左子树 BL 将成为 A 的右子树。
  • B 成为新的子树根节点，而 A 成为 B 的左子节点。

示例图：

插入导致的结构：

  A\B\C

单左旋后的结构：

    B/ \A   C

代码实现：

// 左单旋
void RotateL(Node* parent)
{Node* ppNode = parent->_parent;Node* subR = parent->_right;Node* subRL = subR->_left;parent->_right = subRL;if (subRL){subRL->_parent = parent;}subR->_left = parent;parent->_parent = subR;// 1. 原来 parent 是这棵树的根, 现在 subR 是根if (parent == _root){_root = subR;subR->_parent = nullptr;}// 2. parent 为根的树只是整棵树中的子树, 改变链接关系, 那么 subR 要顶替他的位置else{if (ppNode->_left == parent){ppNode->_left = subR;}else{ppNode->_right = subR;}subR->_parent = ppNode;}parent->_bf = subR->_bf = 0;
}

解释：

  • subR 指向 A 的右子节点 B。
  • B 的左子树 subRL 被挂接到 A 的右子树。
  • B 成为新的根节点，A 成为 B 的左子节点。

3.3.2、右单旋

场景：当新节点插入到某个节点的左子树的左子节点时，可能导致该节点失衡。此时，需要进行右单旋操作来恢复平衡。

旋转过程：

  • 假设不平衡节点为 A，其左子节点为 B。
  • B 的右子树 BR 将成为 A 的左子树。
  • B 成为新的子树根节点，而 A 成为 B 的右子节点。

示例图：

插入导致的结构：

    A/ B   / 
C

单右旋后的结构：

    B/ \C   A

代码实现

// 右单旋
void RotateR(Node* parent)
{Node* ppNode = parent->_parent;Node* subL = parent->_left;Node* subLR = subL->_right;parent->_left = subLR;if (subLR){subLR->_parent = parent;}subL->_right = parent;parent->_parent = subL;if (parent == _root){_root = subL;subL->_parent = nullptr;}else{if (ppNode->_left == parent){ppNode->_left = subL;}else{ppNode->_right = subL;}subL->_parent = ppNode;}parent->_bf = subL->_bf = 0;
}

详细解释：

  • parent 是节点 A
  • subL 指向 A 的左子节点 B。
  • B 的右子树 subLR 被挂接到 A 的左子树。
  • B 成为新的根节点，A 成为 B 的右子节点。

3.3.3、左右双旋

场景：当新节点插入到某个节点的左子树的右子节点时，可能导致该节点失衡。此时，需要先对其左子树进行左旋，再对整个子树进行右旋来恢复平衡。

旋转过程：

  1. 左旋：对左子节点 B 进行单左旋，使得 B 的右子节点 C 成为新的根节点。
  2. 右旋：对不平衡节点 A 进行单右旋，使得 C 成为新的根节点。

示例图：

插入导致的结构：

    A/B\C

左旋后的中间结构：

    A/C/
B

右旋后的最终结构：

    C/ \B   A

代码实现：

// 左右双旋
void RotateLR(Node* parent)
{Node* subL = parent->_left;Node* subLR = subL->_right;int bf = subLR->_bf;RotateL(subL);RotateR(parent);if (bf == 1){parent->_bf = 0;subL->_bf = -1;subLR->_bf = 0;}else if (bf == -1){parent->_bf = 1;subL->_bf = 0;subLR->_bf = 0;}else if (bf == 0){parent->_bf = 0;subL->_bf = 0;subLR->_bf = 0;}
}

解释：

  • 首先对 A 的左子节点 B 进行单左旋，使得 C 成为新的子树根节点。
  • 然后对不平衡节点 A 进行单右旋，使得 C 成为新的根节点。

3.3.4、右左双旋

场景：当新节点插入到某个节点的右子树的左子节点时，可能导致该节点失衡。此时，需要先对其右子树进行右旋，再对整个子树进行左旋来恢复平衡。

旋转过程：

  1. 右旋：对右子节点 B 进行单右旋，使得 B 的左子节点 C 成为新的根节点。
  2. 左旋：对不平衡节点 A 进行单左旋，使得 C 成为新的根节点。

示例图：

插入导致的结构：

  A\B/C

右旋后的中间结构：

  A\C\B

左旋后的最终结构：

    C/ \A   B

代码实现：

// 右左双旋
void RotateRL(Node* parent)
{Node* subR = parent->_right;Node* subRL = subR->_left;int bf = subRL->_bf;RotateR(parent->_right);RotateL(parent);if (bf == -1){parent->_bf = 0;subR->_bf = 1;subRL->_bf = 0;}else if (bf == 1){parent->_bf = -1;subR->_bf = 0;subRL->_bf = 0;}else if (bf == 0){parent->_bf = 0;subR->_bf = 0;subRL->_bf = 0;}
}

解释：

  • 首先对 A 的右子节点 B 进行单右旋，使得 C 成为新的子树根节点。
  • 然后对不平衡节点 A 进行单左旋，使得 C 成为新的根节点。

3.3.5、旋转操作总结

通过这四种旋转操作，AVL 树能够在插入或删除节点后迅速恢复平衡。无论是单旋转还是双旋转，这些操作的时间复杂度都为 O(1) ，因为它们只涉及常数级别的节点重新链接。这使得 AVL 树在保持自平衡状态的同时，能够保证所有基本操作的时间复杂度为 O(log⁡n) 。


3.4、删除操作

在 AVL 树中，节点的删除操作相对复杂，因为删除节点后不仅要移除目标节点，还需要重新平衡树，以保持 AVL 树的平衡性质。AVL 树的删除操作可以分为以下几个步骤：

  1. 找到并删除节点：和普通的二叉搜索树（BST）删除操作类似。
  2. 调整平衡因子：从删除的节点开始，沿着路径向上调整每个节点的平衡因子。
  3. 执行旋转操作：在调整平衡因子的过程中，如果发现某个节点失衡（平衡因子的绝对值大于1），需要进行相应的旋转操作来恢复平衡。

我们将按照这三个步骤详细解释AVL树中节点的删除操作。

3.4.1、找到并删除节点

首先，我们需要在AVL树中找到要删除的节点，并按照 BST 的删除规则将其删除。BST中的删除操作有以下几种情况：

  • 节点是叶子节点：直接删除该节点即可。
  • 节点有一个子节点：用其唯一的子节点替换它。
  • 节点有两个子节点：找到该节点的中序后继节点，用后继节点的值替换该节点的值，然后删除后继节点。

3.4.2、调整平衡因子

在删除节点后，需要调整其祖先节点的平衡因子。沿着从删除节点到根节点的路径进行调整，规则如下：

  • 如果删除的是左子树的节点，则父节点的平衡因子增加1。
  • 如果删除的是右子树的节点，则父节点的平衡因子减少1。

在调整平衡因子的过程中，如果某个节点的平衡因子的绝对值超过1，就需要通过旋转来恢复平衡。

3.4.3、执行旋转操作

在删除节点并调整平衡因子后，如果发现某个节点失衡，则需要根据不同的失衡情况进行旋转操作。

3.4.4、总结

删除操作是AVL树中较为复杂的一部分。需要仔细处理删除节点的不同情况，及时更新平衡因子，并在必要时进行旋转操作以保持树的平衡。每个步骤都需要在 O(log⁡n) 的时间内完成，确保 AVL 树的效率。通过精心设计的平衡调整机制，AVL 树在删除操作后能够快速恢复平衡，保持所有操作的时间复杂度为 O(log⁡n) 。


3.5、遍历操作

在 AVL 树中，遍历是一项基础操作，用于访问树中的每个节点。AVL 树继承了二叉搜索树（BST）的性质，因此可以使用与 BST 相同的遍历方法，包括前序遍历（Pre-order Traversal）、中序遍历（In-order Traversal）、后序遍历（Post-order Traversal）、层序遍历（Level-order Traversal）等。下面将详细介绍这些遍历方法，并给出相应的代码实现。

3.5.1、前序遍历（Pre-order Traversal）

前序遍历的顺序是：先访问根节点，再访问左子树，最后访问右子树。其遍历顺序为 “根 -> 左 -> 右”。

前序遍历的递归实现：

// 前序遍历的递归实现
// 辅助函数
void _PreOrder(Node* root)
{if (root == nullptr){return;}std::cout << root->_kv.first << ":" << root->_kv.second << std::endl;   // 访问根节点_PreOrder(root->_left);   // 访问左子树_PreOrder(root->_right);  // 访问右子树
}void PreOrder()
{_PreOrder(_root);std::cout << std::endl;
}

前序遍历的非递归实现（使用栈）：

// 前序遍历的非递归实现
void PreOrder()
{if (_root == nullptr){return;}std::stack<Node*> stack;stack.push(_root);while (!stack.empty()) {Node* cur = stack.top();stack.pop();std::cout << cur->_kv.first << ":" << cur->_kv.second << std::endl;  // 访问当前节点// 先压入右子树再压入左子树（确保左子树先处理）if (cur->_right != nullptr){stack.push(cur->_right);}if (cur->_left != nullptr) {stack.push(cur->_left);}}std::cout << std::endl;
}

3.5.2、中序遍历（In-order Traversal）

中序遍历的顺序是：先访问左子树，再访问根节点，最后访问右子树。其遍历顺序为 “左 -> 根 -> 右”。对于 AVL 树，中序遍历会得到一个按序排列的节点序列。

中序遍历的递归实现：

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

中序遍历的非递归实现（使用栈）：

// 中序遍历 非递归
void InOrder()
{std::stack<Node*> stack;Node* cur = _root;while (cur != nullptr || !stack.empty()) {// 找到最左边的节点while (cur != nullptr) {stack.push(cur);cur = cur->_left;}// 处理当前节点cur = stack.top();stack.pop();std::cout << cur->_kv.first << ":" << cur->_kv.second << std::endl;// 转向右子树cur = cur->_right;}std::cout << std::endl;
}

3.5.3、后序遍历（Post-order Traversal）

后序遍历的顺序是：先访问左子树，再访问右子树，最后访问根节点。其遍历顺序为 “左 -> 右 -> 根”。

后序遍历的递归实现：

// 后序遍历的递归实现
// 辅助函数
void _PostOrder(Node* root) {if (root == nullptr){return;}_PostOrder(root->_left);    // 访问左子树_PostOrder(root->_right);   // 访问右子树std::cout << root->_kv.first << ":" << root->_kv.second << std::endl;     // 访问根节点
}void PostOrder()
{_PostOrder(_root);std::cout << std::endl;
}

后序遍历的非递归实现（使用栈）：

// 后序遍历的非递归实现
void PostOrder()
{if (_root == nullptr){return;}std::stack<Node*> st;Node* cur = _root;Node* lastNode = nullptr; // 最近访问的节点while (cur || !st.empty()){while (cur){st.push(cur);cur = cur->_left;}Node* top = st.top();if ((top->_right == nullptr) || (lastNode == top->_right)){std::cout << top->_kv.first << ":" << top->_kv.second << std::endl;lastNode = top;st.pop();}else {cur = top->_right;}}std::cout << std::endl;
}

3.5.4、层序遍历（Level-order Traversal）

层序遍历是按层次逐层访问节点，先访问根节点，再访问其左右子节点，依次类推。可以使用队列来实现。

层序遍历的实现：

// 层序遍历
void LevelOrder()
{if (_root == nullptr){return;}std::queue<Node*> queue;queue.push(_root);while (!queue.empty()){Node* cur = queue.front();queue.pop();std::cout << cur->_kv.first << ":" << cur->_kv.second << std::endl;   // 访问当前节点if (cur->_left != nullptr) {queue.push(cur->_left);      // 将左子树压入队列}if (cur->_right != nullptr) {queue.push(cur->_right);     // 将右子树压入队列}}std::cout << std::endl;
}

3.5.5、总结

AVL 树的遍历方法与普通二叉搜索树类似，包括前序遍历、中序遍历、后序遍历和层序遍历。通过递归或非递归方式，我们可以访问 AVL 树的所有节点，并按照特定的顺序输出它们的键值。中**序遍历是最常用的遍历方法之一，特别是在需要输出一个有序序列时。层序遍历则常用于按层次输出或分析树的结构。**每种遍历方法都有其独特的应用场景，在编写和理解 AVL 树的相关算法时，选择合适的遍历方式十分重要。


3.6、查找操作

在AVL树中，查找操作主要依赖于树的有序性，即对于任意一个节点，左子树的所有节点都小于该节点，右子树的所有节点都大于该节点。查找过程从根节点开始，逐层向下比较查找值与当前节点的值，并根据比较结果选择进入左子树或右子树。

3.6.1、查找操作的步骤

  1. 从根节点开始：从AVL树的根节点开始查找。
  2. 比较当前节点的键值：
    • 如果查找的键等于当前节点的键，查找成功，返回当前节点。
    • 如果查找的键小于当前节点的键，进入左子树继续查找。
    • 如果查找的键大于当前节点的键，进入右子树继续查找。
  3. 递归或迭代：重复上述步骤，直到找到匹配的节点或者子树为空（查找失败）。
  4. 返回结果：找到目标节点则返回，否则返回 nullptr（表示查找失败）。

3.6.2、查找的递归实现

递归实现相对简单，直接通过函数递归调用在树中查找目标节点。

// 查找的递归实现
// 辅助函数
Node* _find(Node* root, const K& key)
{if (root == nullptr || root->_kv.first == key){return root;}if (key < root->_kv.first){return _find(root->_left, key);}else{return _find(root->_right, key);}
}

3.6.3、查找的非递归实现

非递归实现使用迭代方式，避免了递归调用带来的额外栈空间开销。

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

4、AVL 树的其他功能

除了基本的插入、查找、删除等操作，AVL 树还可以实现一些高级操作，如查找前驱和后继、区间查询、树的高度、判断是否是平衡二叉树等。这些操作可以扩展 AVL 树的功能，增加其实用性。

4.1、查找后继节点

前驱是指比某个节点值小的最大节点，后继则是比某个节点值大的最小节点。在 AVL 树中，查找前驱和后继是常见的操作，尤其在区间查询或范围搜索时非常有用。

查找后继的递归实现：

// 查找后继节点
Node* findMin(Node* node)
{while (node->_left != nullptr){node = node->_left;}return node;
}Node* FindSuccessor(Node* node)
{if (node->_right != nullptr){return findMin(node->_right);}Node* cur = _root;Node* successor = nullptr;while (cur != nullptr){if (node->_kv.first < cur->_kv.first){successor = cur;cur = cur->_left;}else if (node->_kv.first > cur->_kv.first){cur = cur->_right;}else{break;}}return successor;
}

查找后继时，如果节点有右子树，则后继为右子树中最小的节点；否则，后继为第一个大于该节点的祖先节点。


4.2、查找前驱节点

查找前驱的递归实现：

// 查找前驱节点
Node* findMax(Node* node)
{while (node->_right != nullptr){node = node->_right;}return node;
}Node* FindPredecessor(Node* node)
{if (node->_left != nullptr){return findMax(node->_left);}Node* cur = _root;Node* predecessor = nullptr;while (cur != nullptr){if (node->_kv.first < cur->_kv.first){cur = cur->_left;}else if (node->_kv.first > cur->_kv.first){predecessor = cur;cur = cur->_right;}else{break;}}return predecessor;
}

前驱的查找逻辑与后继类似，只是方向相反。


4.3、获取树的高度

// 获取树的高度
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;
}

4.4、判断是否是平衡二叉树

// 判断是否是平衡二叉树
bool _IsBalance(Node* root)
{if (root == nullptr){return true;}int leftHeight = Height(root->_left);int rightHeight = Height(root->_right);if (abs(leftHeight - rightHeight) > 1){return false;}return _IsBalance(root->_left) && _IsBalance(root->_right);
}bool IsBalance()
{return _IsBalance(_root);
}

5、完整实现代码和测试

5.1、AVLTree.hpp

#pragma once#include <iostream>
#include <stack>
#include <queue>namespace Lenyiin
{template <class K, class V>struct AVLTreeNode{AVLTreeNode<K, V>* _left;AVLTreeNode<K, V>* _right;AVLTreeNode<K, V>* _parent;int _bf;		// balance factor	平衡因子std::pair<K, V> _kv;	// key-value// 普通构造AVLTreeNode(const std::pair<K, V> &kv): _left(nullptr), _right(nullptr), _parent(nullptr), _bf(0), _kv(kv){}};template <class K, class V>class AVLTree{private:typedef AVLTreeNode<K, V> Node;public:bool Insert(const std::pair<K, V>& kv){// 1. 先按搜索树的规则进行插入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->_left;}else if (cur->_kv.first < kv.first){parent = cur;cur = cur->_right;}else{return false;	// 如果相等, 表示已经有了, 不需要插入}}// 找到位置cur = new Node(kv);if (parent->_kv.first > kv.first){parent->_left = cur;cur->_parent = parent;}else{parent->_right = cur;cur->_parent = parent;}// 2. 更新平衡因子while (parent){if (cur == parent->_right){parent->_bf++;	// 插在右边, 平衡因子++}else{parent->_bf--;	// 插在左边, 平衡因子--}if (parent->_bf == 0){// 说明 parent 所在的子树高度不变, 更新结束break;}else if (parent->_bf == 1 || parent->_bf == -1){// 说明 parent 所在子树的高度变了, 继续往上更新cur = parent;parent = parent->_parent;}else if (parent->_bf == 2 || parent->_bf == -2){// parent 所在的子树出现问题了, 需要旋转处理一下// 1. 旋转前提是保持它依旧是搜索二叉树// 2. 旋转成平衡树if (parent->_bf == 2){if (cur->_bf == 1){// 左旋RotateL(parent);}else if (cur->_bf == -1){// 右左双旋RotateRL(parent);}}else if (parent->_bf == -2){if (cur->_bf == -1){// 右旋RotateR(parent);}else if (cur->_bf == 1){// 左右双旋RotateLR(parent);}}// 旋转完成后, parent 所在的树的高度恢复到了插入节点前的高度// 如果是子树, 对上一层没有影响, 更新结束break;}}return true;}// 左单旋void RotateL(Node* parent){Node* ppNode = parent->_parent;Node* subR = parent->_right;Node* subRL = subR->_left;parent->_right = subRL;if (subRL){subRL->_parent = parent;}subR->_left = parent;parent->_parent = subR;// 1. 原来 parent 是这棵树的根, 现在 subR 是根if (parent == _root){_root = subR;subR->_parent = nullptr;}// 2. parent 为根的树只是整棵树中的子树, 改变链接关系, 那么 subR 要顶替他的位置else{if (ppNode->_left == parent){ppNode->_left = subR;}else{ppNode->_right = subR;}subR->_parent = ppNode;}parent->_bf = subR->_bf = 0;}// 右单旋void RotateR(Node* parent){Node* ppNode = parent->_parent;Node* subL = parent->_left;Node* subLR = subL->_right;parent->_left = subLR;if (subLR){subLR->_parent = parent;}subL->_right = parent;parent->_parent = subL;if (parent == _root){_root = subL;subL->_parent = nullptr;}else{if (ppNode->_left == parent){ppNode->_left = subL;}else{ppNode->_right = subL;}subL->_parent = ppNode;}parent->_bf = subL->_bf = 0;}// 右左双旋void RotateRL(Node* parent){Node* subR = parent->_right;Node* subRL = subR->_left;int bf = subRL->_bf;RotateR(parent->_right);RotateL(parent);if (bf == -1){parent->_bf = 0;subR->_bf = 1;subRL->_bf = 0;}else if (bf == 1){parent->_bf = -1;subR->_bf = 0;subRL->_bf = 0;}else if (bf == 0){parent->_bf = 0;subR->_bf = 0;subRL->_bf = 0;}}// 左右双旋void RotateLR(Node* parent){Node* subL = parent->_left;Node* subLR = subL->_right;int bf = subLR->_bf;RotateL(subL);RotateR(parent);if (bf == 1){parent->_bf = 0;subL->_bf = -1;subLR->_bf = 0;}else if (bf == -1){parent->_bf = 1;subL->_bf = 0;subLR->_bf = 0;}else if (bf == 0){parent->_bf = 0;subL->_bf = 0;subLR->_bf = 0;}}// 中序遍历//void _InOrder(Node* root)//{//	if (root == nullptr)//	{//		return;//	}//	_InOrder(root->_left);//	std::cout << root->_kv.first << ":" << root->_kv.second << std::endl;//	_InOrder(root->_right);//}//void InOrder()//{//	_InOrder(_root);//	std::cout << std::endl;//}// 中序遍历 非递归void InOrder(){std::stack<Node*> stack;Node* cur = _root;while (cur != nullptr || !stack.empty()) {// 找到最左边的节点while (cur != nullptr) {stack.push(cur);cur = cur->_left;}// 处理当前节点cur = stack.top();stack.pop();std::cout << cur->_kv.first << ":" << cur->_kv.second << std::endl;// 转向右子树cur = cur->_right;}std::cout << std::endl;}// 前序遍历的递归实现// 辅助函数//void _PreOrder(Node* root)//{//	if (root == nullptr)//	{//		return;//	}//	std::cout << root->_kv.first << ":" << root->_kv.second << std::endl;   // 访问根节点//	_PreOrder(root->_left);   // 访问左子树//	_PreOrder(root->_right);  // 访问右子树//}//void PreOrder()//{//	_PreOrder(_root);//	std::cout << std::endl;//}// 前序遍历的非递归实现void PreOrder(){if (_root == nullptr){return;}std::stack<Node*> stack;stack.push(_root);while (!stack.empty()) {Node* cur = stack.top();stack.pop();std::cout << cur->_kv.first << ":" << cur->_kv.second << std::endl;  // 访问当前节点// 先压入右子树再压入左子树（确保左子树先处理）if (cur->_right != nullptr){stack.push(cur->_right);}if (cur->_left != nullptr) {stack.push(cur->_left);}}std::cout << std::endl;}// 后序遍历的递归实现// 辅助函数//void _PostOrder(Node* root) {//	if (root == nullptr)//	{//		return;//	}//	_PostOrder(root->_left);    // 访问左子树//	_PostOrder(root->_right);   // 访问右子树//	std::cout << root->_kv.first << ":" << root->_kv.second << std::endl;     // 访问根节点//}//void PostOrder()//{//	_PostOrder(_root);//	std::cout << std::endl;//}// 后序遍历的非递归实现void PostOrder(){if (_root == nullptr){return;}std::stack<Node*> st;Node* cur = _root;Node* lastNode = nullptr; // 最近访问的节点while (cur || !st.empty()){while (cur){st.push(cur);cur = cur->_left;}Node* top = st.top();if ((top->_right == nullptr) || (lastNode == top->_right)){std::cout << top->_kv.first << ":" << top->_kv.second << std::endl;lastNode = top;st.pop();}else {cur = top->_right;}}std::cout << std::endl;}// 层序遍历void LevelOrder(){if (_root == nullptr){return;}std::queue<Node*> queue;queue.push(_root);while (!queue.empty()){Node* cur = queue.front();queue.pop();std::cout << cur->_kv.first << ":" << cur->_kv.second << std::endl;   // 访问当前节点if (cur->_left != nullptr) {queue.push(cur->_left);      // 将左子树压入队列}if (cur->_right != nullptr) {queue.push(cur->_right);     // 将右子树压入队列}}std::cout << std::endl;}// 查找后继节点Node* findMin(Node* node){while (node->_left != nullptr){node = node->_left;}return node;}Node* FindSuccessor(Node* node){if (node->_right != nullptr){return findMin(node->_right);}Node* cur = _root;Node* successor = nullptr;while (cur != nullptr){if (node->_kv.first < cur->_kv.first){successor = cur;cur = cur->_left;}else if (node->_kv.first > cur->_kv.first){cur = cur->_right;}else{break;}}return successor;}// 查找前驱节点Node* findMax(Node* node){while (node->_right != nullptr){node = node->_right;}return node;}Node* FindPredecessor(Node* node){if (node->_left != nullptr){return findMax(node->_left);}Node* cur = _root;Node* predecessor = nullptr;while (cur != nullptr){if (node->_kv.first < cur->_kv.first){cur = cur->_left;}else if (node->_kv.first > cur->_kv.first){predecessor = cur;cur = cur->_right;}else{break;}}return predecessor;}// 获取树的高度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(Node* root){if (root == nullptr){return true;}int leftHeight = Height(root->_left);int rightHeight = Height(root->_right);if (abs(leftHeight - rightHeight) > 1){return false;}return _IsBalance(root->_left) && _IsBalance(root->_right);}bool IsBalance(){return _IsBalance(_root);}// 查找 非递归//Node* Find(const K& key)//{//	Node* cur = _root;//	while (cur)//	{//		if (cur->_kv.first > key)//		{//			cur = cur->_left;//		}//		else if (cur->_kv.first < key)//		{//			cur = cur->_right;//		}//		else//		{//			return cur;//		}//	}//	return nullptr;//}// 查找的递归实现// 辅助函数Node* _find(Node* root, const K& key){if (root == nullptr || root->_kv.first == key){return root;}if (key < root->_kv.first){return _find(root->_left, key);}else{return _find(root->_right, key);}}// 查找节点Node* Find(const K& key){return _find(_root, key);}private:Node* _root = nullptr;};
}

5.2、AVLTree.cpp

#include "AVLTree.hpp"using namespace Lenyiin;void test_AVLTree()
{//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };int a[] = {4, 2, 6, 1, 3, 5, 15, 7, 16, 14};AVLTree<int, int> t;for (const auto& e : a){t.Insert(std::make_pair(e, e));}t.InOrder();t.PreOrder();t.PostOrder();t.LevelOrder();std::cout << t.IsBalance() << std::endl;auto ret = t.Find(6);if (ret == nullptr){std::cout << "没有找到" << std::endl;}else{std::cout << "找到了" << std::endl;std::cout << ret->_kv.first << ":" << ret->_kv.second << std::endl;}auto pre = t.FindPredecessor(ret);if (pre != nullptr){std::cout << ret->_kv.first << " 的前驱节点是: " << pre->_kv.first << std::endl;}else{std::cout << "前驱节点为空" << std::endl;}auto suc = t.FindSuccessor(ret);if (suc != nullptr){std::cout << ret->_kv.first << " 的后继节点是: " << suc->_kv.first << std::endl;}else{std::cout << "后继节点为空" << std::endl;}
}int main()
{test_AVLTree();return 0;
}

6、AVL树的优缺点和总结

6.1、优点

  1. 平衡性保证：AVL 树是自平衡二叉搜索树，它严格保持了树的平衡状态。每个节点的左右子树高度差（平衡因子）最多为 1，因此在最坏情况下，AVL 树的高度被限制在 O(log⁡n) 级别。这保证了查找、插入、删除操作的时间复杂度始终为 O(log⁡n) ，使其在各种场景中表现出较高的效率。
  2. 快速查找：由于 AVL 树保持了较高的平衡性，查找操作的性能得到了优化。相比于未平衡的二叉搜索树，AVL 树在查找操作中能够更快地找到目标节点。
  3. 稳定的性能：AVL 树的平衡性维护使得其在最坏情况下（例如频繁的插入和删除操作）也能提供稳定的性能。无论数据插入的顺序如何，AVL 树都能保持平衡，避免出现链表化的情况。
  4. 较好的空间利用率：AVL 树在保持平衡的同时，并不需要额外的节点空间，除了存储平衡因子。相比红黑树等其他自平衡树，AVL 树的平衡性更严格，查找性能更好。

6.2、缺点

  1. 插入和删除的复杂性：AVL 树在插入和删除节点时，需要进行旋转操作以保持树的平衡。每次插入或删除操作都可能导致树的不平衡，从而触发重新平衡过程。虽然旋转操作的时间复杂度为 O(1) ，但在频繁的插入和删除场景中，这些旋转操作可能增加整体的处理时间。
  2. 实现复杂性：AVL 树的实现相对较复杂，尤其是插入和删除操作。与红黑树相比，AVL 树需要更多的旋转操作来维持平衡，这使得其代码编写和维护的难度较大。
  3. 额外的存储空间：为了维护平衡性，AVL 树的每个节点需要额外存储平衡因子(balance factor)，这增加了节点的内存开销。虽然这一开销较小，但对于内存非常敏感的系统，可能会有一定的影响。
  4. 性能折衷：尽管 AVL 树在查找操作中表现优异，但其插入和删除操作的性能可能会受到影响。在一些场景中，如需要频繁插入和删除的情况下，红黑树可能比 AVL 树更具优势，因为红黑树的旋转操作次数通常比 AVL 树少。

6.3、总结

AVL 树是一种自平衡的二叉搜索树，它通过在每次插入和删除节点时自动调整自身结构，确保树的高度始终保持在 O(log⁡n) 级别，从而提供高效的查找、插入和删除操作。AVL 树的核心优势在于其严格的平衡性，这使得它在查找操作中具有较高的性能，并且在最坏情况下也能保持较优的时间复杂度。

然而，这种严格的平衡性也带来了更高的实现复杂性和插入、删除操作的额外开销。在需要频繁插入和删除的应用场景中，AVL 树的性能可能不如红黑树等其他自平衡树。此外，AVL 树的每个节点需要额外存储平衡因子，略微增加了内存开销。

尽管如此，AVL 树在追求高效查找操作的场景中仍然是一个非常实用的数据结构。它适用于需要快速数据访问、并且插入和删除操作相对较少的场景，如字典、集合等。在实际应用中，应根据具体的需求和场景，综合考虑选择适合的自平衡二叉树结构。

通过本博客对 AVL 树的全面阐述，希望能够帮助读者更好地理解和运用 AVL 树，并在实际开发中合理选择和实现这一数据结构。



希望这篇博客对您有所帮助，也欢迎您在此基础上进行更多的探索和改进。如果您有任何问题或建议，欢迎在评论区留言，我们可以共同探讨和学习。更多知识分享可以访问我的个人博客网站 ： https://blog.lenyiin.com/ 。本博客所涉及的代码也可以访问我的 git 仓库获取 ：https://git.lenyiin.com/Lenyiin/AVLTree



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

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

相关文章

C++ 常用设计模式

C++ 常用设计模式

1、单例模式 一个类只有一个实例&#xff0c;提供一个全局访问点来访问这个实例。 分为懒汉模式和饿汉模式&#xff1a; 懒汉模式就是 只有用到这个实例才会初始化对象并返回 &#xff08;调用了对外的接口才实例化对象&#xff09;饿汉模式就是 不管用不用得到&#xff0c;都…
阅读更多...
Unity3D 小案例 像素贪吃蛇 02 蛇的觅食

Unity3D 小案例 像素贪吃蛇 02 蛇的觅食

Unity3D 小案例 像素贪吃蛇 第二期 蛇的觅食 像素贪吃蛇 食物生成 在场景中创建一个 2D 正方形&#xff0c;调整颜色&#xff0c;添加 Tag 并修改为 Food。 然后拖拽到 Assets 文件夹中变成预制体。 创建食物管理器 FoodManager.cs&#xff0c;添加单例&#xff0c;可以设置…
阅读更多...
【VitualBox】VitualBox的网络模式+网络配置

【VitualBox】VitualBox的网络模式+网络配置

VirtualBox 1. 简介 VirtualBox 是一款开源虚拟机软件&#xff0c;使用者可以在VirtualBox上安装并且执行Solaris、Windows、DOS、Linux、OS/2 Warp、BSD等系统作为客户端操作系统。 2. 六种网络接入模式 VirtualBox提供了多种网络接入模式&#xff0c;他们各有优缺点&#xf…
阅读更多...
YOLOv8改进 | 自定义数据集训练 | AirNet助力YOLOv8检测

YOLOv8改进 | 自定义数据集训练 | AirNet助力YOLOv8检测

目录 一、本文介绍 二、AirNet原理介绍 2.1 对比基降解编码器&#xff08;CBDE&#xff09; 2.2 降解引导修复网络&#xff08;DGRN&#xff09; 三、yolov8与AirNet结合修改教程 3.1 核心代码文件的创建与添加 3.1.1 AirNet.py文件添加 3.1.2 __init__.py文件添加 3…
阅读更多...
【qt】一个WPS项目了解qt界面设计的基本套路

【qt】一个WPS项目了解qt界面设计的基本套路

项目功能演示: 放心食用!最后有完整代码. 超级详细,期待您的一个点赞❥(^_-) 一览全局: WPS项目目录 一.创建项目二.导入资源三.ui设计四.字号选择框初始化五.滚动条初始化六.添加自定义文本类七.初始化action状态八.新建文档九.打开文件十.保存与另存为十一.打印/打印预览十…
阅读更多...
vue 入门一

vue 入门一

参考&#xff1a;丁丁的哔哩哔哩 1.使用vue 1.1 使用CDN的方式使用Vue mount和<div id"counter">关联起来 1.2 vue中的createApp import { createApp } from "vue"; import App from "./App.vue"; createApp(App).mount("#app&qu…
阅读更多...
PyTorch使用------自动微分模块

PyTorch使用------自动微分模块

目录 &#x1f354; 梯度基本计算 1.1 单标量梯度的计算 1.2 单向量梯度的计算 1.3 多标量梯度计算 1.4 多向量梯度计算 1.5 运行结果&#x1f4af; &#x1f354; 控制梯度计算 2.1 控制不计算梯度 2.2 注意: 累计梯度 2.3 梯度下降优化最优解 2.4 运行结果&#x1…
阅读更多...
数字工厂管理系统与MES系统在实际应用中有哪些区别

数字工厂管理系统与MES系统在实际应用中有哪些区别

随着制造业的数字化转型步伐加快&#xff0c;数字工厂管理系统与制造执行MES系统作为两大关键工具&#xff0c;在实际应用中展现出了明显的差异。本文将从实际应用的角度&#xff0c;详细探讨这两种系统之间的主要区别。 数字工厂管理系统的实际应用 数字工厂管理系统侧重于对…
阅读更多...
掌握Spring Boot数据库集成：用JPA和Hibernate构建高效数据交互与版本控制

掌握Spring Boot数据库集成：用JPA和Hibernate构建高效数据交互与版本控制

在现代应用开发中&#xff0c;数据库操作是核心环节之一。Spring Boot提供了简化数据库集成的强大工具&#xff0c;而JPA&#xff08;Java Persistence API&#xff09;和Hibernate是两种非常流行的ORM&#xff08;对象关系映射&#xff09;框架&#xff0c;可以帮助我们将对象…
阅读更多...
如何删除EXCELL文件中的空行？

如何删除EXCELL文件中的空行？

1&#xff0c;选择某一列 2&#xff0c;点击《开始》《查找和选择》>《定位条件》&#xff0c;调出《定位条件》的选择框&#xff1b; 3&#xff0c;在定位条件选项框&#xff0c;选择《空值》&#xff1b; 4&#xff0c;找到变灰被选中的某一行&#xff0c;右击《删除》 5&…
阅读更多...
GitLab权限及设置

GitLab权限及设置

之前很少关注这些&#xff0c;项目的权限&#xff0c;一般由专门的管理人员设置。 但自己创建的项目自己可以设置权限。下面是一些笔记。 GitLab中用户权限_gitlab 权限-CSDN博客 开发中遇到要将自己这块的代码上传到Git&#xff0c;由其他组的同事拉取后继续开发。上传代码后…
阅读更多...
JavaScript 笔记汇总

JavaScript 笔记汇总

JavaScript 笔记汇总 引入方式 内部方式 通过 script 标签包裹 JavaScript 代码。 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>JavaScript 基础 - 引入方式</title> </head> <…
阅读更多...
SpringBoot Kafka发送消息与接收消息实例

SpringBoot Kafka发送消息与接收消息实例

前言 Kafka的基本工作原理 我们将消息的发布&#xff08;publish&#xff09;称作 producer(生产者)&#xff0c;将消息的订阅&#xff08;subscribe&#xff09;表述为 consumer&#xff08;消费者&#xff09;&#xff0c;将中间的存储阵列称作 broker(代理)&#xff0c;这…
阅读更多...
QT打开摄像头采集

QT打开摄像头采集

QT打开摄像头采集 今天好不容易把opencv的环境装好&#xff0c;然后想学习一下人脸识别的功能&#xff0c;但是在图书馆坐了4个多小时了&#xff0c;屁股疼就先写个摄像头采集的功能&#xff0c;明天继续学习吧&#xff0c;废话不多&#xff0c;嚼个奶片开始发车&#xff01;&…
阅读更多...
JVM java主流的追踪式垃圾收集器

JVM java主流的追踪式垃圾收集器

目录 前言 分代垃圾收集理论 标记清除算法 标记复制算法 标记整理法 前言 从对象消亡的角度出发, 垃圾回收器可以分为引用计数式垃圾收集和追踪式垃圾收集两大类, 但是java主流的一般是追踪式的垃圾收集器, 因此我们重点讲解. 分代垃圾收集理论 分代收集这种理…
阅读更多...
Linux Vim编辑器常用命令

Linux Vim编辑器常用命令

目录 一、命令模式快捷键 二、编辑/输入模式快捷键 三、编辑模式切换到命令模式 四、搜索命令 注&#xff1a;本章内容全部基于Centos7进行操作&#xff0c;查阅本章节内容前请确保您当前所在的Linux系统版本&#xff0c;且具有足够的权限执行操作。 一、命令模式快捷键 二…
阅读更多...
企业专用智能云盘 | 帮助企业便捷管控企业文档 | 天锐绿盘云文档安全管理系统

企业专用智能云盘 | 帮助企业便捷管控企业文档 | 天锐绿盘云文档安全管理系统

由于当前多数企业内部的办公文件普遍散落于各员工电脑中&#xff0c;导致存在诸多潜在的文档使用风险。为优化团队协作效率&#xff0c;天 锐 绿盘是一款集文档统一管理、高效协同于一体的企业云盘&#xff0c;帮助企业解决文档管理中的诸多难题。 【地址&#xff1a;点击了解天…
阅读更多...
【2023工业异常检测文献】SimpleNet

【2023工业异常检测文献】SimpleNet

SimpleNet:ASimpleNetworkforImageAnomalyDetectionandLocalization 1、Background 图像异常检测和定位主要任务是识别并定位图像中异常区域。 工业异常检测最大的难题在于异常样本少&#xff0c;一般采用无监督方法&#xff0c;在训练过程中只使用正常样本。 解决工业异常检…
阅读更多...
TCP客户端编码和解码处理：发送和接收指定编码消息

TCP客户端编码和解码处理：发送和接收指定编码消息

文章目录 引言基于Netty实现TCP客户端Netty发送GBK编码指令Netty接收GBK编码基于Channel发送指令基于ChannelHandlerContext发送指令：建立连接时发送登陆指令开启日志，查看报文信息基于ChannelInboundHandlerAdapter进行业务逻辑处理原生API实现TCP客户端基于DataOutputStrea…
阅读更多...
AI预测福彩3D采取888=3策略+和值012路或胆码测试9月19日新模型预测第92弹

AI预测福彩3D采取888=3策略+和值012路或胆码测试9月19日新模型预测第92弹

经过90多期的测试&#xff0c;当然有很多彩友也一直在观察我每天发的预测结果&#xff0c;得到了一个非常有价值的信息&#xff0c;那就是9码定位的命中率非常高&#xff0c;90多期一共只错了10次&#xff0c;这给喜欢打私房菜的朋友提供了极高价值的预测结果~当然了&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023