树-AVL最优二叉树
作者：互联网
AVL树
#include<iostream>
using namespace std;
class Node{
public:
int data;
Node* left;
Node* right;
Node():left(NULL),right(NULL),data(0){}
Node(int data):data(data),left(NULL),right(NULL){}
};
class AVLTree{
Node* root;
Node* treeMax(Node* root){
while(root->right){
root = root->right;
}
return root;
}
bool _isNodeWithTwoChild(Node* root){
if((root->left)&&(root->right)){
return true;
}else{
return false;
}
}
Node* _search(Node* root,int k){
if(root==NULL){
return root;
}
if((root->data)>k){
return _search(root->left,k);
}else if((root->data)<k){
return _search(root->right,k);
}else if((root->data)==k){
return root;
}
}
int _height(Node* root){
if(root==NULL){
return 0;
}else{
return max(_height(root->left),_height(root->right))+1;
}
}
int _diff(Node* root){
return _height(root->left) - _height(root->right);
}
Node* ll_Rotation(Node* root){
Node* tmp = root->left;
root->left = tmp->right;
tmp->right = root;
return tmp;
}
Node* rr_Rotation(Node* root){
Node* tmp = root->right;
root->right = tmp->left;
tmp->left = root;
return tmp;
}
Node* lr_Rotation(Node* root){
Node* tmp1 = root->left;
root->left = rr_Rotation(tmp1);
return ll_Rotation(root);
}
Node* rl_Rotation(Node* root){
Node* tmp = root->right;
root->right = ll_Rotation(tmp);
return rr_Rotation(root);
}
Node* _Balance(Node* root){
int balance = _diff(root);
if(balance > 1){
if(_diff(root->left) > 0){
return ll_Rotation(root);
}else{
return lr_Rotation(root);
}
}else if(balance<-1){
if(_diff(root->right) > 0){
return rl_Rotation(root);
}else{
return rr_Rotation(root);
}
}
return root;
}
Node* _insert(Node* root,int key){
if(root == NULL){
Node* tmp;
tmp->data = key;
root = tmp;
return root;
}else if(key<root->data){
root->left = _insert(root->left,key);
root = _Balance(root);
}else if(key>root->data){
root->left = _insert(root->right,key);
root = _Balance(root);
}
return root;
}
Node* _delete(Node* root,int key){
Node* tmp;tmp = root;
if(root == NULL){
return root;
}
if(!_search(tmp,key)){
cout<<"Sorry do not find!"<<endl;
return root;
}
if(key == root->data){
if(_isNodeWithTwoChild(root)){
if(_diff(root)>0){
root->data = treeMax(root->left)->data;
_delete(root->left,root->data);
}else{
root->data = treeMax(root->right)->data;
_delete(root->right,root->data);
}
}else{
Node* tmp = root;
root = (root->left)?(root->left):(root->right);
delete tmp;
tmp = NULL;
}
}else if(key < root->data){
root->left = _delete(root->left,key);
if(_diff(root->right)>0){
root = rl_Rotation(root);
}else{
root = rr_Rotation(root);
}
}else{
root->right = _delete(root->right,key);
if(_diff(root) > 1){
if(_diff(root->left) < 0){
root = lr_Rotation(root);
}else{
root = ll_Rotation(root);
}
}
}
return root;
}
};
AVL模板
忘记是哪位大神的了，是我半年前学习的模板。（侵删）
#ifndef AVL_TREE_H
#define AVL_TREE_H
#include<iostream>
using namespace std;
template <typename Comparable>
class AVLTree
{
public:
typedef enum _order {PREORDER, INORDER, POSTORDER} ORDER; // 通过enum定义常量
public:
AVLTree() :m_root(nullptr){}
AVLTree(const AVLTree &rhs)
{
m_root = clone(rhs.m_root);
}
~AVLTree()
{
makeEmpty();
}
/**
* 返回树的高度。空树的高度定义为-1
*/
int getHeight() const
{
return m_root.height;
}
/**
* 找到树中的最小值，通过调用private的findMin实现递归
*/
const Comparable & findMin() const
{
return findMin(m_root)->element;
}
/**
* 找到树中的最大值，通过调用private的findMax实现递归
*/
const Comparable & findMax() const
{
return findMax(m_root)->element;
}
/**
* 当x找到时返回真，否则返回假
* 调用了private的那个同名函数，这个是为了递归实现
*（因为private中包含了一个AVLNode的指针t）
*/
bool contains(const Comparable &x) const
{
return contains(x, m_root);
}
/**
* 判断树是否为空
*/
bool isEmpty() const
{
return nullptr == m_root;
}
/**
* 把树遍历一遍（顺序可以自己选择，默认为中序）
*/
void printTree(ORDER or = INORDER, ostream & out = cout) const
{
if (isEmpty())
out << "Empty tree!" << endl;
else
{
switch (or)
{
case PREORDER:
preOrder(m_root, cout);
break;
case INORDER:
inOrder(m_root, cout);
break;
case POSTORDER:
postOrder(m_root, cout);
break;
default:
cerr << "打印树的顺序只能为PREORDER, INORDER, POSTORDER!" << endl;
break;
}
}
}
/**
* 清空树
*/
void makeEmpty()
{
makeEmpty(m_root);
}
/**
* 把x插入树中，如果重复了就忽略
*/
void insert(const Comparable &x)
{
insert(x, m_root);
}
/**
* 把x从树中删除。如果x不在树中就什么都不做。
*/
void remove(const Comparable &x)
{
remove(x, m_root);
}
/**
* 深拷贝
*/
const AVLTree & operator= (const AVLTree &rhs)
{
if (this != &rhs)
{
AVLNode *tmp = clone(rhs.m_root);
makeEmpty();
m_root = tmp;
}
return *this;
}
private:
struct AVLNode{
Comparable element;
AVLNode *left;
AVLNode *right;
int height;
AVLNode(const Comparable &theElement,
AVLNode *lt,
AVLNode *rt,
int h = 0)
: element(theElement), left(lt), right(rt), height(h) {}
};
AVLNode *m_root; // 根节点
static const int ALLOW_IMBALANCE = 1; // 允许实施平衡的高度界限
/**
* 用于比较两个数的大小（主要用于比较高度）
*/
int max (int a, int b)
{
return a >= b ? a : b;
}
/**
* 获得节点高度,空树的高度为-1
*/
inline int height(AVLNode *t) const
{
return nullptr == t ? -1 : t->height;
}
/**
* 在树t中插入元素x，如果重复则什么也不做
*/
void insert(const Comparable &x, AVLNode * &t);
/**
* 在树t中删除元素x
*/
void remove(const Comparable &x, AVLNode * &t);
/**
* 查找最小的元素, 通过递归的方法
*/
AVLNode * findMin(AVLNode *t) const;
/**
* 查找最大的元素, 通过循环的方法
*/
AVLNode * findMax(AVLNode *t) const;
/**
* 通过遍历的方法查找x是否在树（或子树）t中
*/
bool contains(const Comparable &x, AVLNode * t) const;
/**
* 清空树
*/
void makeEmpty(AVLNode * &t);
/**
* 按前序打印子树
*/
void preOrder(AVLNode *t, ostream & out) const;
/**
* 按中序打印子树
*/
void inOrder(AVLNode *t, ostream & out) const;
/**
* 按后序打印子树
*/
void postOrder(AVLNode *t, ostream & out) const;
/**
* 复制子树
*/
AVLNode * clone(AVLNode *t) const;
/**
* 平衡子树
*/
void balance(AVLNode * &t);
/**
* 左旋（右子树比左子树高2，并且新插入的元素在右子树的右边）
* 此时以右子树(k1)为轴，它的根(k2)进行左旋
* 可以理解为它的根在它的左边，所以左旋（在左边旋转）
* K2 K1
* / \ / \
* X k1 ----- K2 Z
* / \ / \ \
* Y Z X Y Z'
* \
* Z'
* Z'可能在Z的左边，也可以在Z的右边。例子中假设在右边。
**/
void rotateWithRightChild(AVLNode * & k2);
/**
* 右旋（左子树比右子树高2，并且新插入的元素在左子树的左边）
* 此时以左子树（k1）为轴，它的根（k2）进行右旋
* 可以理解为它的根在它的右边，所以右旋（在右边旋转）
* k2 k1
* / \ / \
* k1 Z ------- X k2
* / \ / / \
* X Y X' Y Z
* /
* X'
* X'可能在X的左边，也可以在X的右边。例子中假设在左边。
*/
void rotateWithLeftChild(AVLNode * & k2);
/**
* 左右双旋（左子树K1比右子树D高2，并且新插入的元素在左子树K1的右边K2）
* 第一步：对左子树k1进行一次左旋(轴为k2)
* 第二步：对整个树k3进行一次右旋（轴为k2）
* k3 k3 k2
* / \ / \ / \
* k1 D ---- k2 D ---- k1 k3
* / \ / \ / \ / \
* A k2 k1 C A B C D
* / \ / \
* B C A B
*/
void doubleWithLeftChild(AVLNode * & k3);
/**
* 右左双旋（右子树K1比左子树A高2，并且新插入的元素在右子树K1的左边K2）
* 第一步：对右子树k1进行一次右旋（轴为k2）
* 第二步：对整个树k3进行一次左旋（轴为k2）
* k3 k3 k2
* / \ / \ / \
* A k1 ---- A k2 ---- k3 k1
* / \ / \ / \ / \
* K2 D B k1 A B C D
* / \ / \
* B C C D
*/
void doubleWithRightChild(AVLNode * & k3);
/**
* 更新节点的高度
*/
inline void updateHeight(AVLNode * & t)
{
t->height = max(height(t->left), height(t->right)) + 1;
}
};
/**
* 复制子树
*/
template <typename Comparable>
typename AVLTree<Comparable>::AVLNode *
AVLTree<Comparable>::clone(
typename AVLTree<Comparable>::AVLNode *t) const
{
if (t == nullptr)
return nullptr;
return new AVLNode(t->element, clone(t->left), clone(t->right));
}
/**
* 按前序打印子树
*/
template <typename Comparable>
void AVLTree<Comparable>::preOrder(
typename AVLTree<Comparable>::AVLNode*t,
ostream & out) const
{
if (nullptr != t)
{
out << t->element << endl;
preOrder(t->left, out);
preOrder(t->right, out);
}
}
/**
* 按中序打印子树
*/
template <typename Comparable>
void AVLTree<Comparable>::inOrder(
typename AVLTree<Comparable>::AVLNode *t,
ostream & out) const
{
if (nullptr != t)
{
inOrder(t->left, out);
out << t->element << endl;
inOrder(t->right, out);
}
}
/**
* 按后序打印子树
*/
template <typename Comparable>
void AVLTree<Comparable>::postOrder(
typename AVLTree<Comparable>::AVLNode*t,
ostream & out) const
{
if (nullptr != t)
{
postOrder(t->left, out);
postOrder(t->right, out);
out << t->element << endl;
}
}
/**
* 清空树
*/
template <typename Comparable>
void AVLTree<Comparable>::makeEmpty(
typename AVLTree<Comparable>::AVLNode * &t)
{
if (t != nullptr)
{
makeEmpty(t->left);
makeEmpty(t->right);
delete t;
}
t = nullptr;
}
/**
* 查找最小的元素, 通过递归的方法
*/
template <typename Comparable>
typename AVLTree<Comparable>::AVLNode *
AVLTree<Comparable>::findMin(
typename AVLTree<Comparable>::AVLNode *t) const
{
if (t == nullptr)
return nullptr;
if (t->left == nullptr)
return t;
return findMin(t->left);
}
/**
* 查找最大的元素, 通过循环的方法
*/
template <typename Comparable>
typename AVLTree<Comparable>::AVLNode *
AVLTree<Comparable>::findMax(
typename AVLTree<Comparable>::AVLNode *t) const
{
if (t != nullptr)
while (t->right != nullptr)
t = t->right;
return t;
}
/**
* 在树t中删除元素x,一定要主要保持树的平衡
*/
template <typename Comparable>
void AVLTree<Comparable>::remove(
const Comparable &x,
typename AVLTree<Comparable>::AVLNode * &t)
{
if (t == nullptr)
return; // 没有找要删除的节点x
if (x < t->element)
remove(x, t->left);
else if (t->element < x)
remove(x, t->right);
else if (t->left != nullptr &&
t->right != nullptr)
{
t->element = findMin(t->right)->element;
remove(t->element, t->right);
}
else
{
//typename AVLTree<Comparable>::AVLNode * oldNode = t;
auto oldNode = t; // 这一句等于上面的那长长的语句，可以看出C++11中的auto还是非常有用 的
t = (t->left != nullptr) ? t->left : t->right;
delete oldNode;
}
balance(t);
}
/**
* 在树t中插入元素x，如果重复则什么也不做
*/
template <typename Comparable>
void AVLTree<Comparable>::insert(
const Comparable &x,
typename AVLTree<Comparable>::AVLNode * &t)
{
if (nullptr == t)
t = new AVLNode(x, nullptr, nullptr);
else if (x < t->element)
{
insert(x, t->left); // 如果带插入的值小于目前的节点，则插入在左子树
/*
if (height(t->left) - height(t->right) == 2) // 插入后如果节点的左子树比右子树高2
{
if (x < t->left->element)
rotateWithLeftChild(t); // 右旋
else
doubleWithLeftChild(t); // 左-右双旋
}
*/
}
else if (t->element < x)
{
insert(x, t->right);// 如果带插入的值大于目前的节点，则插入在右子树
/*
if (height(t->right) - height(t->left) == 2)// 插入后如果节点的右子树比左子树高2
{
if (t->right->element < x)
rotateWithRightChild(t); // 左旋
else
doubleWithRightChild(t); // 右-左双旋
}
*/
}
else
; // 表示在树中找到了x，则什么也不做
balance(t); // 每次完成插入都检查子树是否平衡（并且默认更新节点t的高度）
}
/**
* 平衡子树
*/
template <typename Comparable>
void AVLTree<Comparable>::balance(
typename AVLTree<Comparable>::AVLNode * &t)
{
if (nullptr == t)
return;
// 如果左子树的高度与右子树高度差大于实施平衡调整的限度
if (height(t->left) - height(t->right) > AVLTree<Comparable>::ALLOW_IMBALANCE)
{
// 判断是左子树的左边高还是右边高，如果左子树左边高
if (height(t->left->left) >= height(t->left->right))
{
rotateWithLeftChild(t);
}
else
{
doubleWithLeftChild(t);
}
}
// 如果右子树的高度与左子树高度差大于实施平衡调整的限度
else if (height(t->right) - height(t->left) > AVLTree<Comparable>::ALLOW_IMBALANCE)
{
if (height(t->right->right) >= height(t->right->left))
{
rotateWithRightChild(t);
}
else
{
doubleWithRightChild(t);
}
}
else
;
updateHeight(t);
}
/**
* 通过遍历的方法查找x是否在树（或子树）t中
*/
template <typename Comparable>
bool AVLTree<Comparable>::contains(
const Comparable &x,
typename AVLTree<Comparable>::AVLNode * t) const
{
if (t == nullptr) // 遍历中未找到元素的中止条件
return false;
else if (x < t->element)
return contains(x, t->left);
else if (t->element < x)
return contains(x, t->right);
else // 如果 x 不大于 也 不小于t所指的节点中的元素，则x==t->element
return true;
}
/**
* 右旋（左子树比右子树高2，并且新插入的元素在左子树的左边）
* 此时以左子树（k1）为轴，它的根（k2）进行右旋
* 可以理解为它的根在它的右边，所以右旋（在右边旋转）
* k2 k1
* / \ / \
* k1 Z ------- X k2
* / \ / / \
* X Y X' Y Z
* /
* X'
* X'可能在X的左边，也可以在X的右边。例子中假设在左边。
*/
template <typename Comparable>
void AVLTree<Comparable>::rotateWithLeftChild(
typename AVLTree<Comparable>::AVLNode * & k2)
{
//typename AVLTree<Comparable>::AVLNode * k1 = k2->left; // 获得k2的左节点
auto k1 = k2->left; // 使用auto定义
// 开始旋转
k2->left = k1->right;
k1->right = k2;
//更新高度, 先更新k2可以，更新k1时减少一次height函数的调用
k2->height = max(height(k2->left), height(k2->right)) + 1;//等价于updateHeight(k2)
k1->height = max(height(k1->left), k2->height) + 1;
k2 = k1;
}
/**
* 左旋（右子树比左子树高2，并且新插入的元素在右子树的右边）
* 此时以右子树(k1)为轴，它的根(k2)进行左旋
* 可以理解为它的根在它的左边，所以左旋（在左边旋转）
* K2 K1
* / \ / \
* X k1 ----- K2 Z
* / \ / \ \
* Y Z X Y Z'
* \
* Z'
* Z'可能在Z的左边，也可以在Z的右边。例子中假设在右边。
**/
template <typename Comparable>
void AVLTree<Comparable>::rotateWithRightChild(
typename AVLTree<Comparable>::AVLNode * & k2)
{
//typename AVLTree<Comparable>::AVLNode * k1 = k2->right;
auto k1 = k2->right; // 使用auto定义
// 开始旋转
k2->right = k1->left;
k1->left = k2;
//更新高度, 先更新k2可以减少一次height函数的调用
k2->height = max(height(k2->left), height(k2->right)) + 1;
k1->height = max(k2->height, height(k1->right)) + 1;
k2 = k1;
}
/**
* 左右双旋（左子树K1比右子树D高2，并且新插入的元素在左子树K1的右边K2）
* 第一步：对左子树k1进行一次左旋(轴为k2)
* 第二步：对整个树k3进行一次右旋（轴为k2）
* k3 k3 k2
* / \ / \ / \
* k1 D ---- k2 D ---- k1 k3
* / \ / \ / \ / \
* A k2 k1 C A B C D
* / \ / \
* B C A B
* 注：一般来说，只会有B或C一个存在，就会进行树的平衡调整
*/
template <typename Comparable>
void AVLTree<Comparable>::doubleWithLeftChild(
typename AVLTree<Comparable>::AVLNode * & k3)
{
rotateWithRightChild(k3->left);
rotateWithLeftChild(k3);
}
/**
* 右左双旋（右子树K1比左子树A高2，并且新插入的元素在右子树K1的左边K2）
* 第一步：对右子树k1进行一次右旋（轴为k2）
* 第二步：对整个树k3进行一次左旋（轴为k2）
* k3 k3 k2
* / \ / \ / \
* A k1 ---- A k2 ---- k3 k1
* / \ / \ / \ / \
* K2 D B k1 A B C D
* / \ / \
* B C C D
*注：一般来说，只会有B或C一个存在，就会进行树的平衡调整
*/
template <typename Comparable>
void AVLTree<Comparable>::doubleWithRightChild(
typename AVLTree<Comparable>::AVLNode * & k3)
{
rotateWithLeftChild(k3->right);
rotateWithRightChild(k3);
}
#endif //AVL_TREE_H
标签：right,AVLTree,AVLNode,AVL,k2,二叉树,最优,root,left 来源： https://blog.csdn.net/weixin_42340366/article/details/90739230