AVL树

AVL树的各种变换图

//AVL 树
#include
#include
#include
using namespace std;
template
struct TreeNode
{
T _val;
TreeNode* _left;
TreeNode* _right;
int bf;
TreeNode* _parent;
TreeNode(const T& val = T())
:_val(val), _left(nullptr), _right(nullptr),bf(0),_parent(nullptr)
{}
};
template
class AVLTree
{
public:
typedef TreeNode Node;
AVLTree()
:_root(nullptr)
{}
bool insert(const T& val)
{
Node* cur = _root;
Node* parent = nullptr;
if (cur == nullptr)
{
cur = new Node(val);
_root = cur;
return true;
}
while (cur)
{
parent = cur;
if (cur->_val == val)
return false;
else if (cur->_val > val)
{
cur = cur->_left;
}
else if (cur->_val < val)
{
cur = cur->_right;
}
}
cur = new Node(val);
if (cur->_val > parent->_val)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
cur->_parent = parent;
while (parent)
{
if (parent->_left == cur)
{
parent->bf–;
}
else
{
parent->bf++;
}
if (parent->bf == 0)
{
break;
}
else if (parent->bf == 1 || parent->bf == -1)
{
cur = parent;
parent = cur->_parent;
}
else if (parent->bf == 2||parent->bf==-2)
{
if (parent->bf == 2 && cur->bf == 1)//右边的右边高
{
rorateLeft(parent);
}
else if (parent->bf == -2 && cur->bf == -1)//左边的左边高
{
rorateRight(parent);
}
else if(parent->bf2&&cur->bf-1)//右边的左边高
{
rorateRL(parent);
}
else //左边的右边高
{
rorateLR(parent);
}
break;
}
}
return true;
}
void rorateRight(Node* parent)
{
Node* SubL = parent->_left;
Node* SubLR = SubL->_right;
parent->_left = SubLR;
if (SubLR)
{
SubLR->_parent = parent;
}
SubL->_right = parent;
if (parent == _root)
{
SubL->_parent = nullptr;
_root = SubL;
}
else
{
SubL->_parent = parent->_parent;
if (parent->_parent->_left == parent)
{
parent->_parent->_left = SubL;
}
else
{
parent->_parent->_right = SubL;
}
}
parent->_parent = SubL;
parent->bf = SubL->bf = 0;
}
void rorateLeft(Node* parent)
{
Node* SubR = parent->_right;
Node* SubRL = SubR->_left;
parent->_right = SubRL;
if (SubRL)
{
SubRL->_parent = parent;
}
SubR->_left = parent;
if (parent == _root)
{
SubR->_parent = nullptr;
_root = SubR;
}
else
{
SubR->_parent = parent->_parent;
if (parent->_parent->_left == parent)
{
parent->_parent->_left = SubR;
}
else
parent->_parent->_right = SubR;
}
parent->_parent = SubR;
parent->bf = SubR->bf = 0;
}
void rorateRL(Node* parent)
{
Node* SubR = parent->_right;
Node* SubRL = SubR->_left;
int bf = SubRL->bf;
rorateRight(SubR);
rorateLeft(parent);
if (bf == -1)
{
SubR->bf = 1;
parent->bf = 0;
}
else if (bf == 1)
{
SubR->bf = 0;
parent->bf = -1;
}
}
void rorateLR(Node* parent)
{
Node* SubL = parent->_left;
Node* SubLR = SubL->_right;
int bf = SubLR->bf;
rorateLeft(parent->_left);
rorateRight(parent);
if (bf == 1)
{
SubL->bf = -1;
parent->bf = 0;
}
else
{
SubL->bf = 0;
parent->bf = 1;
}
}
void inorder()
{
inorder(_root);
}
void inorder(Node* root)
{
if (root == nullptr)
return;
inorder(root->_left);
cout << root->_val << " ";
inorder(root->_right);
}
bool isBlance()
{
return isBlance(_root);
}
bool isBlance(Node* cur)
{
if (cur == nullptr)
return true;
//判断左右节点高度是否和平衡因子相同
int distance = High(cur->_right) - High(cur->_left);
if (cur->bf != distance)
{
cout << “异常” << endl;
return false;
}
return abs(cur->bf)<2&&isBlance(cur->_left) && isBlance(cur->_right);
}
int High(Node* parent)
{
if (parent == nullptr)
return 0;
int left = High(parent->_left);
int right = High(parent->_right);
return left > right ? left+1 : right+1;
}
private:
Node* _root;
};
void test()
{
AVLTreeavl;
int array[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16,14 };
for (const auto& e : array)
avl.insert(e);
avl.inorder();
cout << endl;
cout << avl.isBlance() << endl;
}
int main()
{
test();
return 0;
}