写到前面的话:
作者从毕业开始一直从事游戏开发,提供大量游戏实战模块代码及案例供大家学习与交流,希望以下知识可以带来一些帮助,如有任何疑问,请加群641792143交流与学习 或关注微信公众号 程序员干货区
闻道有先后,术业有专攻,希望大家不吝赐教
下面是公众号
首先:
问:什么树才叫AVL树?
答:1、二叉查找树 2、平衡二叉树
那么什么树才叫二叉查找树
只要满足上图说的两个原则那他就是一个二叉查找树
那么什么叫平衡二叉树?
只要满足上面两点那就是一颗AVL树
接下来开始上代码:
1.数据结构的定义(本文采用模板T类型 为了更接近企业级代码)
template<typename T>
class Node
{
public:
Node()
{
}
inline operator T& ()
{
return data_;
}
T data_;
int balance_; //AVL树的平衡因子(右节点的高度 - 左节点的高度)
Node<T>* left_; //左节点
Node<T>* right_;//右节点
Node<T>* parent_;//父节点
};
template <typename T>
class AVLTree
{
public:
AVLTree()
{
tree_ = NULL;
// count_ = 0;
}
virtual ~AVLTree()
{
clear();
// count_ = 0;
}
//清空AVLTree
virtual void clear(Node<T>* node = NULL)
{
if (!node) node = tree_;
if (!node) return;
Node<T>* left = node->left_;
Node<T>* right = node->right_;
delete node;
node = NULL;
//这里还要去释放自己类内申请的内存
{
if (left)
clear(left);
if (right)
clear(right);
}
}
inline int height(Node<T>* node)
{
if (node == NULL)
{
return 0;
}
int rightheight = height(node->right_);
int leftheight = height(node->left_);
return rightheight > leftheight ? (rightheight + 1) : (leftheight + 1);
}
inline void setBalance(Node<T>* node)
{
if (node)
node->balance_ = height(node->right_) - height(node->left_);
}
//查询操作 递归查询 未找到返回可以插入的根节点
//const T& value 要查询的value
//Node<T>* root 从哪个根节点开始查询 默认从根节点开始
Node<T>* select(const T& value, Node<T>* root = NULL);
//插入操作
void insert(const T& value, Node<T>* root = NULL);
//将节点右旋
Node<T>* turnRight(Node<T>* node);
//将节点左旋
Node<T>* turnLeft(Node<T>* node);
//先左旋再右旋
Node<T>* turnLeftThenRight(Node<T>* node)
{
node->left_ = turnLeft(node->left_);
return turnRight(node);
}
//先右旋再左旋
Node<T>* turnRightThenLeft(Node<T>* node)
{
node->right_ = turnRight(node->right_);
return turnLeft(node);
}
//获取该根节点上最小的节点
inline Node<T>* getmin(Node<T>* node)
{
if (node->left_)
getmin(node->left_);
else
return node;
}
//重新平衡node节点
void rebalance(Node<T>* node);
//删除节点 当该节点只有一个子节点或没有子节点
void delnodeifhas1childornot(Node<T>* node);
//删除该节点 且该节点有两个孩子节点
void delnodeifhas2child(Node<T>* node);
//删除node节点
void del(const T& value, Node<T>* node);
private:
Node<T>* tree_; //AVL tree的树根
// int count_; //节点数
};
2.节点的查询
//查询操作 递归查询 未找到返回可以插入的根节点
//const T& value 要查询的value
//Node<T>* root 从哪个根节点开始查询 默认从根节点开始
Node<T>* select(const T& value, Node<T>* root = NULL)
{
if (!root) root = tree_;
if (!root) return NULL;
if (root->data_ == value) //找到该节点
return root;
else if (root->data_ > value) //
{
if (root->left_)
return select(value, root->left_); //继续到左子节点查询
else
return root; //返回根节点
}
else if (root->data_ < value)
{
if (root->right_)
return select(value, root->right_); //继续到右子节点查询
else
return root;//返回根节点
}
return NULL;
}
3.节点的插入
扩展:讲到二叉树失衡,那就要讲解二叉树失衡的方式以及如何解决二叉树失衡
二叉树失衡的4种情形:
上图介绍了两种只需要进行一次旋转就能使二叉树重新达到平衡的情形
上图介绍了两种需要进行两次旋转就能使二叉树重新达到平衡的情形
结论:
1.当根节点平衡因子 = -2 ,且与左子节点的平衡因子符号相同,则需要右旋
2.当根节点平衡因子 = 2,且与右子节点的平衡因子符号相同,则需要左旋
3.当根节点平衡因子 = -2 ,且与左子节点的平衡因子符号不一致时,则需要先右旋后左旋
4.当根节点平衡因子 = 2 ,且与右子节点的平衡因子符号不一致时,则需要先左旋后右旋
//将节点右旋
Node<T>* turnRight(Node<T>* node)
{
// 右旋使node的父节点的子节点替换为b
Node<T>* b = node->left_;
if (node->parent_ != NULL) {
if (node->parent_->right_ == node)
{
node->parent_->right_ = b;
}
else
{
node->parent_->left_ = b;
}
}
b->parent_ = node->parent_;
//将b的右子树作为a的左子树,并将a作为b的右子树
node->parent_ = b;
node->left_ = b->right_;
if (node->left_ != NULL)
node->left_->parent_ = node;
b->right_ = node;
//重新设置a、b节点的balance值
setBalance(node);
setBalance(b);
//返回b节点
return b;
}
//将节点左旋
Node<T>* turnLeft(Node<T>* node)
{
//左旋把node的父节点的子节点替换为b
Node<T>* b = node->right_;
if (node->parent_ != NULL) {
if (node->parent_->right_ == node) {
node->parent_->right_ = b;
}
else {
node->parent_->left_ = b;
}
}
b->parent_ = node->parent_;
//将node作为b的左子树,并将b的左子树作为node的右子树
node->parent_ = b;
node->right_ = b->left_;
b->left_ = node;
if (node->right_ != NULL)
node->right_->parent_ = node;
//重新设置node、b的balance值
setBalance(node);
setBalance(b);
//返回b节点
return b;
}
//插入操作
void insert(const T& value, Node<T>* root = NULL)
{
if (!root) root = tree_;
Node<T>* node = select(value, root);
if (node == NULL) //为空 代表tree为空
{
tree_ = new Node<T>;
tree_->data_ = value;
tree_->left_ = tree_->right_ = NULL;
tree_->parent_ = NULL;
tree_->balance_ = 0;
}
else if (node->data_ != value)
{
Node<T>* newNode = new Node<T>;
newNode->data_ = value;
newNode->right_ = newNode->left_ = NULL;
newNode->parent_ = node;
newNode->balance_ = 0;
if (node->data_ > value) //新增节点比跟节点小 则查到根节点的左节点上
{
node->left_ = newNode;
}
else if (node->data_ < value)//新增节点比跟节点大 则查到根节点的右节点上
{
node->right_ = newNode;
}
rebalance(node);
}
}
4.节点的删除
![在这里插入图片描述](https://img-blog.csdnimg.cn/2019121523261340.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xwbDMxMjkwNTUwOQ==,size_16,color_FFFFFF,t_70
//接下来上节点删除的代码
//重新平衡node节点
void rebalance(Node<T>* node)
{
setBalance(node);
if (node->balance_ == -2) {
if (node->left_->balance_ <= 0) //符号相同
{
node = turnRight(node); //右旋
}
else //符号不同 需要两次旋转
{
node = turnLeftThenRight(node);
}
}
else if (node->balance_ == 2)
{
if (node->right_->balance_ >= 0)//符号相同
{
node = turnLeft(node);
}
else//符号不同 需要两次旋转
{
node = turnRightThenLeft(node);
}
}
if (node->parent_)
{
rebalance(node->parent_);
}
else
{
tree_ = node;
}
}
//删除节点 当该节点只有一个子节点或没有子节点
void delnodeifhas1childornot(Node<T>* node)
{
if (!node) return;
if (node->parent_ == NULL)
{
if (node->left_)
{
tree_ = node->left_;
node->left_->parent_ = NULL;
}
else
{
tree_ = node->right_;
node->right_->parent_ = NULL;
}
}
else
{
if (node->parent_->left_ == node)
{
if (node->left_)
{
node->parent_->left_ = node->left_;
node->left_->parent_ = node->parent_;
}
else
{
node->parent_->left_ = node->right_;
if (node->right_)
node->right_->parent_ = node->parent_;
}
}
else
{
if (node->left_)
{
node->parent_->right_ = node->left_;
node->left_->parent_ = node->parent_;
}
else
{
node->parent_->right_ = node->right_;
if (node->right_)
node->right_->parent_ = node->parent_;
}
}
rebalance(node->parent_);
}
delete node;
node = NULL;
}
//删除该节点 且该节点有两个孩子节点
void delnodeifhas2child(Node<T>* node)
{
Node<T>* after = getmin(node->right_);
node->data_ = after->value;
delnodeifhas1childornot(after);
}
//删除node节点
void del(const T& value, Node<T>* node)
{
Node<T>* node = select(value, root);
if (node->data_ == value)
{
if (node->left_ && node->right_) {
delnodeifhas2child(node);
}
else
{
delnodeifhas1childornot(node);
}
}
}
算是完整讲解完了AVL树的原理,恐怕还是有疏漏之处,请大牛们不吝赐教,如有问题或疑问,请加群641792143交流与学习,避免闭门造车
下面贴出完整代码:
#include <assert.h>
#include <iostream>
using namespace std;
template<typename T>
class Node
{
public:
Node()
{
}
inline operator T& ()
{
return data_;
}
T data_;
int balance_; //AVL树的平衡因子(右节点的高度 - 左节点的高度)
Node<T>* left_; //左节点
Node<T>* right_;//右节点
Node<T>* parent_;//父节点
};
template <typename T>
class AVLTree
{
public:
AVLTree()
{
tree_ = NULL;
count_ = 0;
}
virtual ~AVLTree()
{
clear();
count_ = 0;
}
//清空AVLTree
virtual void clear(Node<T>* node = NULL)
{
if (!node) node = tree_;
if (!node) return;
Node<T>* left = node->left_;
Node<T>* right = node->right_;
delete node;
node = NULL;
//这里还要去释放自己类内申请的内存
{
if (left)
clear(left);
if (right)
clear(right);
}
}
inline int height(Node<T>* node)
{
if (node == NULL)
{
return 0;
}
int rightheight = height(node->right_);
int leftheight = height(node->left_);
return rightheight > leftheight ? (rightheight + 1) : (leftheight + 1);
}
inline void setBalance(Node<T>* node)
{
if (node)
node->balance_ = height(node->right_) - height(node->left_);
}
//查询操作 递归查询 未找到返回可以插入的根节点
//const T& value 要查询的value
//Node<T>* root 从哪个根节点开始查询 默认从根节点开始
Node<T>* select(const T& value, Node<T>* root = NULL)
{
if (!root) root = tree_;
if (!root) return NULL;
if (root->data_ == value) //找到该节点
return root;
else if (root->data_ > value) //
{
if (root->left_)
return select(value, root->left_); //继续到左子节点查询
else
return root; //返回根节点
}
else if (root->data_ < value)
{
if (root->right_)
return select(value, root->right_); //继续到右子节点查询
else
return root;//返回根节点
}
return NULL;
}
//插入操作
void insert(const T& value, Node<T>* root = NULL)
{
if (!root) root = tree_;
Node<T>* node = select(value, root);
if (node == NULL) //为空 代表tree为空
{
tree_ = new Node<T>;
tree_->data_ = value;
tree_->left_ = tree_->right_ = NULL;
tree_->parent_ = NULL;
tree_->balance_ = 0;
}
else if (node->data_ != value)
{
Node<T>* newNode = new Node<T>;
newNode->data_ = value;
newNode->right_ = newNode->left_ = NULL;
newNode->parent_ = node;
newNode->balance_ = 0;
if (node->data_ > value) //新增节点比跟节点小 则查到根节点的左节点上
{
node->left_ = newNode;
}
else if (node->data_ < value)//新增节点比跟节点大 则查到根节点的右节点上
{
node->right_ = newNode;
}
rebalance(node);
}
}
//将节点右旋
Node<T>* turnRight(Node<T>* node)
{
// 右旋使node的父节点的子节点替换为b
Node<T>* b = node->left_;
if (node->parent_ != NULL) {
if (node->parent_->right_ == node)
{
node->parent_->right_ = b;
}
else
{
node->parent_->left_ = b;
}
}
b->parent_ = node->parent_;
//将b的右子树作为a的左子树,并将a作为b的右子树
node->parent_ = b;
node->left_ = b->right_;
if (node->left_ != NULL)
node->left_->parent_ = node;
b->right_ = node;
//重新设置a、b节点的balance值
setBalance(node);
setBalance(b);
//返回b节点
return b;
}
//将节点左旋
Node<T>* turnLeft(Node<T>* node)
{
//左旋把node的父节点的子节点替换为b
Node<T>* b = node->right_;
if (node->parent_ != NULL) {
if (node->parent_->right_ == node) {
node->parent_->right_ = b;
}
else {
node->parent_->left_ = b;
}
}
b->parent_ = node->parent_;
//将node作为b的左子树,并将b的左子树作为node的右子树
node->parent_ = b;
node->right_ = b->left_;
b->left_ = node;
if (node->right_ != NULL)
node->right_->parent_ = node;
//重新设置node、b的balance值
setBalance(node);
setBalance(b);
//返回b节点
return b;
}
//先左旋再右旋
Node<T>* turnLeftThenRight(Node<T>* node)
{
node->left_ = turnLeft(node->left_);
return turnRight(node);
}
//先右旋再左旋
Node<T>* turnRightThenLeft(Node<T>* node)
{
node->right_ = turnRight(node->right_);
return turnLeft(node);
}
//获取该根节点上最小的节点
inline Node<T>* getmin(Node<T>* node)
{
if (node->left_)
getmin(node->left_);
else
return node;
}
//重新平衡node节点
void rebalance(Node<T>* node)
{
setBalance(node);
if (node->balance_ == -2) {
if (node->left_->balance_ <= 0) //符号相同
{
node = turnRight(node); //右旋
}
else //符号不同 需要两次旋转
{
node = turnLeftThenRight(node);
}
}
else if (node->balance_ == 2)
{
if (node->right_->balance_ >= 0)//符号相同
{
node = turnLeft(node);
}
else//符号不同 需要两次旋转
{
node = turnRightThenLeft(node);
}
}
if (node->parent_)
{
rebalance(node->parent_);
}
else
{
tree_ = node;
}
}
//删除节点 当该节点只有一个子节点或没有子节点
void delnodeifhas1childornot(Node<T>* node)
{
if (!node) return;
if (node->parent_ == NULL)
{
if (node->left_)
{
tree_ = node->left_;
node->left_->parent_ = NULL;
}
else
{
tree_ = node->right_;
node->right_->parent_ = NULL;
}
}
else
{
if (node->parent_->left_ == node)
{
if (node->left_)
{
node->parent_->left_ = node->left_;
node->left_->parent_ = node->parent_;
}
else
{
node->parent_->left_ = node->right_;
if (node->right_)
node->right_->parent_ = node->parent_;
}
}
else
{
if (node->left_)
{
node->parent_->right_ = node->left_;
node->left_->parent_ = node->parent_;
}
else
{
node->parent_->right_ = node->right_;
if (node->right_)
node->right_->parent_ = node->parent_;
}
}
rebalance(node->parent_);
}
delete node;
node = NULL;
}
//删除该节点 且该节点有两个孩子节点
void delnodeifhas2child(Node<T>* node)
{
Node<T>* after = getmin(node->right_);
node->data_ = after->value;
delnodeifhas1childornot(after);
}
//删除node节点
void del(const T& value, Node<T>* node)
{
Node<T>* node = select(value, root);
if (node->data_ == value)
{
if (node->left_ && node->right_) {
delnodeifhas2child(node);
}
else
{
delnodeifhas1childornot(node);
}
}
}
private:
Node<T>* tree_; //AVL tree的树根
int count_; //节点数
};
int main()
{
{
AVLTree<int> avlTree;
avlTree.insert(5);
avlTree.insert(6);
avlTree.insert(7);
}
system("pause");
return 0;
}