详细的具体步骤 :

一篇讲的很好博客

AVL,红黑树优先博客-Never

先对二叉树的不平衡结构进行总结:

各种旋转 特别注意字母含义(结构)和其旋转操作之间的区别

二叉树不平衡结构 性质 平衡操作
LL root bf =2 root->left 进行右旋操作
RR root bf=-2 root->right 进行左旋操作
LR root bf=2,root->left bf=-1 root->left 进行 RR左旋操作,root根结点进行LL右旋操作
RL root bf=-2,root->right bf=1 root->right 进行LL 右旋操作,root根结点进行RR左旋操作

cpp的完整实现

AVL.c文件中也有图 旋转步骤

// 1.LL : left-left
/*
* 对于LL只需要进行单旋转就可以
*/ /*
* insert node =i
*
* k2 k1
* / \ 平衡 / \
* k1 z -----\ x k2
* / \ -----/ \ / \
* x y i y z
* \
* i
*/ static Node* left_left_rotation(AVLTree k2)
{
// 结点重新连接
AVLTree k1;
k1=k2->left; // 得到旋转后的根结点
k2->left=k1->right; // y结点进行修改
k1->right=k2; // 原根结点向右旋转 // 结点高度保存值的update 更新
k2->height=MAX(HEIGHT(k2->right),HEIGHT(k2->left))+1;
k1->height=MAX(HEIGHT(k1->left),k2->height)+1; return k1; // 返回新根结点
} // 2 RR right_right
/*
* RR也是自需要进行单旋转
* insert node =i
*
* k2 k1
* / \ / \
* x k1 ------\ k2 z
* / \ ------/ / \ \
* y z x y i
* \
* i
*/
static Node* right_right_rotation(AVLTree k2)
{
AVLTree k1;
k1=k2->right;
k2->right=k1->left;
k1->left=k2; k2->height=MAX(HEIGHT(k2->left),HEIGHT(k2->right))+1;
k1->HEIGHT=MAX(HEIGHT(k1->right),k2->height)+1; return k1;
} // 3 LR left_right
/*
* LR 需要进行双旋转才可以恢复平衡
* 第一步,对left结点 RR
* 第二步,根结点进行LL
*
* k3 k3 k2
* / \ RR / \ LL / \
* k1 d ----\ k2 d ----\ k1 k3
* / \ ----/ / \ ----/ / \ / \
* a k2 k1 c a b c d
* / \ / \
* b c a b
*/ static Node* left_right_rotation(AVLTree k3)
{
k3->left=right_right_rotation(k3->left);
return left_left_rotation(k3);
} // 4 RL right_left
/*
* RL 需要惊醒双旋转
* 第一步,对right结点进行LL
* 第二步,对根结点进行RR
*
* k1 k1 k2
* / \ LL / \ RR / \
* a k3 ----\ a k2 -----\ k1 k3
* / \ ----/ / \ -----/ / \ / \
* k2 d b k3 a b c d
* / \ / \
* b c c d
*/ static Node* right_left_rotation(AVLTree k1)
{
k1->right=left_left_rotation(k1->right);
return right_right_rotation(k1);
}

附上完整实现的CPP代码

头文件

#ifndef _AVL_TREE_HPP_
#define _AVL_TREE_HPP_ #include <iomanip>
#include <iostream>
using namespace std; template <class T>
class AVLTreeNode{
public:
T key; // 关键字(键值)
int height; // 高度
AVLTreeNode *left; // 左孩子
AVLTreeNode *right; // 右孩子 AVLTreeNode(T value, AVLTreeNode *l, AVLTreeNode *r):
key(value), height(0),left(l),right(r) {}
}; template <class T>
class AVLTree {
private:
AVLTreeNode<T> *mRoot; // 根结点 public:
AVLTree();
~AVLTree(); // 获取树的高度
int height();
// 获取树的高度
int max(int a, int b); // 前序遍历"AVL树"
void preOrder();
// 中序遍历"AVL树"
void inOrder();
// 后序遍历"AVL树"
void postOrder(); // (递归实现)查找"AVL树"中键值为key的节点
AVLTreeNode<T>* search(T key);
// (非递归实现)查找"AVL树"中键值为key的节点
AVLTreeNode<T>* iterativeSearch(T key); // 查找最小结点:返回最小结点的键值。
T minimum();
// 查找最大结点:返回最大结点的键值。
T maximum(); // 将结点(key为节点键值)插入到AVL树中
void insert(T key); // 删除结点(key为节点键值)
void remove(T key); // 销毁AVL树
void destroy(); // 打印AVL树
void print();
private:
// 获取树的高度
int height(AVLTreeNode<T>* tree) ; // 前序遍历"AVL树"
void preOrder(AVLTreeNode<T>* tree) const;
// 中序遍历"AVL树"
void inOrder(AVLTreeNode<T>* tree) const;
// 后序遍历"AVL树"
void postOrder(AVLTreeNode<T>* tree) const; // (递归实现)查找"AVL树x"中键值为key的节点
AVLTreeNode<T>* search(AVLTreeNode<T>* x, T key) const;
// (非递归实现)查找"AVL树x"中键值为key的节点
AVLTreeNode<T>* iterativeSearch(AVLTreeNode<T>* x, T key) const; // 查找最小结点:返回tree为根结点的AVL树的最小结点。
AVLTreeNode<T>* minimum(AVLTreeNode<T>* tree);
// 查找最大结点:返回tree为根结点的AVL树的最大结点。
AVLTreeNode<T>* maximum(AVLTreeNode<T>* tree); // LL:左左对应的情况(左单旋转)。
AVLTreeNode<T>* leftLeftRotation(AVLTreeNode<T>* k2); // RR:右右对应的情况(右单旋转)。
AVLTreeNode<T>* rightRightRotation(AVLTreeNode<T>* k1); // LR:左右对应的情况(左双旋转)。
AVLTreeNode<T>* leftRightRotation(AVLTreeNode<T>* k3); // RL:右左对应的情况(右双旋转)。
AVLTreeNode<T>* rightLeftRotation(AVLTreeNode<T>* k1); // 将结点(z)插入到AVL树(tree)中
AVLTreeNode<T>* insert(AVLTreeNode<T>* &tree, T key); // 删除AVL树(tree)中的结点(z),并返回被删除的结点
AVLTreeNode<T>* remove(AVLTreeNode<T>* &tree, AVLTreeNode<T>* z); // 销毁AVL树
void destroy(AVLTreeNode<T>* &tree); // 打印AVL树
void print(AVLTreeNode<T>* tree, T key, int direction);
}; /*
* 构造函数
*/
template <class T>
AVLTree<T>::AVLTree():mRoot(NULL)
{
} /*
* 析构函数
*/
template <class T>
AVLTree<T>::~AVLTree()
{
destroy(mRoot);
} /*
* 获取树的高度
*/
template <class T>
int AVLTree<T>::height(AVLTreeNode<T>* tree)
{
if (tree != NULL)
return tree->height; return 0;
} template <class T>
int AVLTree<T>::height()
{
return height(mRoot);
}
/*
* 比较两个值的大小
*/
template <class T>
int AVLTree<T>::max(int a, int b)
{
return a>b ? a : b;
} /*
* 前序遍历"AVL树"
*/
template <class T>
void AVLTree<T>::preOrder(AVLTreeNode<T>* tree) const
{
if(tree != NULL)
{
cout<< tree->key << " " ;
preOrder(tree->left);
preOrder(tree->right);
}
} template <class T>
void AVLTree<T>::preOrder()
{
preOrder(mRoot);
} /*
* 中序遍历"AVL树"
*/
template <class T>
void AVLTree<T>::inOrder(AVLTreeNode<T>* tree) const
{
if(tree != NULL)
{
inOrder(tree->left);
cout<< tree->key << " " ;
inOrder(tree->right);
}
} template <class T>
void AVLTree<T>::inOrder()
{
inOrder(mRoot);
} /*
* 后序遍历"AVL树"
*/
template <class T>
void AVLTree<T>::postOrder(AVLTreeNode<T>* tree) const
{
if(tree != NULL)
{
postOrder(tree->left);
postOrder(tree->right);
cout<< tree->key << " " ;
}
} template <class T>
void AVLTree<T>::postOrder()
{
postOrder(mRoot);
} /*
* (递归实现)查找"AVL树x"中键值为key的节点
*/
template <class T>
AVLTreeNode<T>* AVLTree<T>::search(AVLTreeNode<T>* x, T key) const
{
if (x==NULL || x->key==key)
return x; if (key < x->key)
return search(x->left, key);
else
return search(x->right, key);
} template <class T>
AVLTreeNode<T>* AVLTree<T>::search(T key)
{
return search(mRoot, key);
} /*
* (非递归实现)查找"AVL树x"中键值为key的节点
*/
template <class T>
AVLTreeNode<T>* AVLTree<T>::iterativeSearch(AVLTreeNode<T>* x, T key) const
{
while ((x!=NULL) && (x->key!=key))
{
if (key < x->key)
x = x->left;
else
x = x->right;
} return x;
} template <class T>
AVLTreeNode<T>* AVLTree<T>::iterativeSearch(T key)
{
return iterativeSearch(mRoot, key);
} /*
* 查找最小结点:返回tree为根结点的AVL树的最小结点。
*/
template <class T>
AVLTreeNode<T>* AVLTree<T>::minimum(AVLTreeNode<T>* tree)
{
if (tree == NULL)
return NULL; while(tree->left != NULL)
tree = tree->left;
return tree;
} template <class T>
T AVLTree<T>::minimum()
{
AVLTreeNode<T> *p = minimum(mRoot);
if (p != NULL)
return p->key; return (T)NULL;
} /*
* 查找最大结点:返回tree为根结点的AVL树的最大结点。
*/
template <class T>
AVLTreeNode<T>* AVLTree<T>::maximum(AVLTreeNode<T>* tree)
{
if (tree == NULL)
return NULL; while(tree->right != NULL)
tree = tree->right;
return tree;
} template <class T>
T AVLTree<T>::maximum()
{
AVLTreeNode<T> *p = maximum(mRoot);
if (p != NULL)
return p->key; return (T)NULL;
} /*
* LL:左左对应的情况(左单旋转)。
*
* 返回值:旋转后的根节点
*/
template <class T>
AVLTreeNode<T>* AVLTree<T>::leftLeftRotation(AVLTreeNode<T>* k2)
{
AVLTreeNode<T>* k1; k1 = k2->left;
k2->left = k1->right;
k1->right = k2; k2->height = max( height(k2->left), height(k2->right)) + 1;
k1->height = max( height(k1->left), k2->height) + 1; return k1;
} /*
* RR:右右对应的情况(右单旋转)。
*
* 返回值:旋转后的根节点
*/
template <class T>
AVLTreeNode<T>* AVLTree<T>::rightRightRotation(AVLTreeNode<T>* k1)
{
AVLTreeNode<T>* k2; k2 = k1->right;
k1->right = k2->left;
k2->left = k1; k1->height = max( height(k1->left), height(k1->right)) + 1;
k2->height = max( height(k2->right), k1->height) + 1; return k2;
} /*
* LR:左右对应的情况(左双旋转)。
*
* 返回值:旋转后的根节点
*/
template <class T>
AVLTreeNode<T>* AVLTree<T>::leftRightRotation(AVLTreeNode<T>* k3)
{
k3->left = rightRightRotation(k3->left); return leftLeftRotation(k3);
} /*
* RL:右左对应的情况(右双旋转)。
*
* 返回值:旋转后的根节点
*/
template <class T>
AVLTreeNode<T>* AVLTree<T>::rightLeftRotation(AVLTreeNode<T>* k1)
{
k1->right = leftLeftRotation(k1->right); return rightRightRotation(k1);
} /*
* 将结点插入到AVL树中,并返回根节点
*
* 参数说明:
* tree AVL树的根结点
* key 插入的结点的键值
* 返回值:
* 根节点
*/
template <class T>
AVLTreeNode<T>* AVLTree<T>::insert(AVLTreeNode<T>* &tree, T key)
{
if (tree == NULL)
{
// 新建节点
tree = new AVLTreeNode<T>(key, NULL, NULL);
if (tree==NULL)
{
cout << "ERROR: create avltree node failed!" << endl;
return NULL;
}
}
else if (key < tree->key) // 应该将key插入到"tree的左子树"的情况
{
tree->left = insert(tree->left, key);
// 插入节点后,若AVL树失去平衡,则进行相应的调节。
if (height(tree->left) - height(tree->right) == 2)
{
if (key < tree->left->key)
tree = leftLeftRotation(tree);
else
tree = leftRightRotation(tree);
}
}
else if (key > tree->key) // 应该将key插入到"tree的右子树"的情况
{
tree->right = insert(tree->right, key);
// 插入节点后,若AVL树失去平衡,则进行相应的调节。
if (height(tree->right) - height(tree->left) == 2)
{
if (key > tree->right->key)
tree = rightRightRotation(tree);
else
tree = rightLeftRotation(tree);
}
}
else //key == tree->key)
{
cout << "添加失败:不允许添加相同的节点!" << endl;
} tree->height = max( height(tree->left), height(tree->right)) + 1; return tree;
} template <class T>
void AVLTree<T>::insert(T key)
{
insert(mRoot, key);
} /*
* 删除结点(z),返回根节点
*
* 参数说明:
* tree AVL树的根结点
* z 待删除的结点
* 返回值:
* 根节点
*/
template <class T>
AVLTreeNode<T>* AVLTree<T>::remove(AVLTreeNode<T>* &tree, AVLTreeNode<T>* z)
{
// 根为空 或者 没有要删除的节点,直接返回NULL。
if (tree==NULL || z==NULL)
return NULL; if (z->key < tree->key) // 待删除的节点在"tree的左子树"中
{
tree->left = remove(tree->left, z);
// 删除节点后,若AVL树失去平衡,则进行相应的调节。
if (height(tree->right) - height(tree->left) == 2)
{
AVLTreeNode<T> *r = tree->right;
if (height(r->left) > height(r->right))
tree = rightLeftRotation(tree);
else
tree = rightRightRotation(tree);
}
}
else if (z->key > tree->key)// 待删除的节点在"tree的右子树"中
{
tree->right = remove(tree->right, z);
// 删除节点后,若AVL树失去平衡,则进行相应的调节。
if (height(tree->left) - height(tree->right) == 2)
{
AVLTreeNode<T> *l = tree->left;
if (height(l->right) > height(l->left))
tree = leftRightRotation(tree);
else
tree = leftLeftRotation(tree);
}
}
else // tree是对应要删除的节点。
{
// tree的左右孩子都非空
if ((tree->left!=NULL) && (tree->right!=NULL))
{
if (height(tree->left) > height(tree->right))
{
// 如果tree的左子树比右子树高;
// 则(01)找出tree的左子树中的最大节点
// (02)将该最大节点的值赋值给tree。
// (03)删除该最大节点。
// 这类似于用"tree的左子树中最大节点"做"tree"的替身;
// 采用这种方式的好处是:删除"tree的左子树中最大节点"之后,AVL树仍然是平衡的。
AVLTreeNode<T>* max = maximum(tree->left);
tree->key = max->key;
tree->left = remove(tree->left, max);
}
else
{
// 如果tree的左子树不比右子树高(即它们相等,或右子树比左子树高1)
// 则(01)找出tree的右子树中的最小节点
// (02)将该最小节点的值赋值给tree。
// (03)删除该最小节点。
// 这类似于用"tree的右子树中最小节点"做"tree"的替身;
// 采用这种方式的好处是:删除"tree的右子树中最小节点"之后,AVL树仍然是平衡的。
AVLTreeNode<T>* min = maximum(tree->right);
tree->key = min->key;
tree->right = remove(tree->right, min);
}
}
else
{
AVLTreeNode<T>* tmp = tree;
tree = (tree->left!=NULL) ? tree->left : tree->right;
delete tmp;
}
} return tree;
} template <class T>
void AVLTree<T>::remove(T key)
{
AVLTreeNode<T>* z; if ((z = search(mRoot, key)) != NULL)
mRoot = remove(mRoot, z);
} /*
* 销毁AVL树
*/
template <class T>
void AVLTree<T>::destroy(AVLTreeNode<T>* &tree)
{
if (tree==NULL)
return ; if (tree->left != NULL)
destroy(tree->left);
if (tree->right != NULL)
destroy(tree->right); delete tree;
} template <class T>
void AVLTree<T>::destroy()
{
destroy(mRoot);
} /*
* 打印"二叉查找树"
*
* key -- 节点的键值
* direction -- 0,表示该节点是根节点;
* -1,表示该节点是它的父结点的左孩子;
* 1,表示该节点是它的父结点的右孩子。
*/
template <class T>
void AVLTree<T>::print(AVLTreeNode<T>* tree, T key, int direction)
{
if(tree != NULL)
{
if(direction==0) // tree是根节点
cout << setw(2) << tree->key << " is root" << endl;
else // tree是分支节点
cout << setw(2) << tree->key << " is " << setw(2) << key << "'s " << setw(12) << (direction==1?"right child" : "left child") << endl; print(tree->left, tree->key, -1);
print(tree->right,tree->key, 1);
}
} template <class T>
void AVLTree<T>::print()
{
if (mRoot != NULL)
print(mRoot, mRoot->key, 0);
}
#endif

函数文件

/**
* Cpp 语言: AVL树
*
* @author skywang
* @date 2013/11/07
* test_code
*/ #include <iostream>
#include "AVLTree.h"
using namespace std; static int arr[]= {3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9};
#define TBL_SIZE(a) ( (sizeof(a)) / (sizeof(a[0])) ) int main()
{
int i,ilen;
AVLTree<int>* tree=new AVLTree<int>(); cout << "== 依次添加: ";
ilen = TBL_SIZE(arr);
for(i=0; i<ilen; i++)
{
cout << arr[i] <<" ";
tree->insert(arr[i]);
} cout << "\n== 前序遍历: ";
tree->preOrder(); cout << "\n== 中序遍历: ";
tree->inOrder(); cout << "\n== 后序遍历: ";
tree->postOrder();
cout << endl; cout << "== 高度: " << tree->height() << endl;
cout << "== 最小值: " << tree->minimum() << endl;
cout << "== 最大值: " << tree->maximum() << endl;
cout << "== 树的详细信息: " << endl;
tree->print(); i = 8;
cout << "\n== 删除根节点: " << i;
tree->remove(i); cout << "\n== 高度: " << tree->height() ;
cout << "\n== 中序遍历: " ;
tree->inOrder();
cout << "\n== 树的详细信息: " << endl;
tree->print(); // 销毁二叉树
tree->destroy(); return 0;
}

AVL自平衡二叉树的更多相关文章

  1. 数据结构树之AVL树(平衡二叉树)

    一 什么是AVL树(平衡二叉树): AVL树本质上是一颗二叉查找树,但是它又具有以下特点:它是一棵空树或它的左右两个子树的高度差的绝对值不超过1,并且左右两个子树都是一棵平衡二叉树.在AVL树中任何节 ...

  2. 转:红黑树和AVL树(平衡二叉树)区别

    本文转载至链接:https://blog.csdn.net/u010899985/article/details/80981053 一.AVL树(平衡二叉树) (1)简介 AVL树是带有平衡条件的二叉 ...

  3. 树·AVL树/平衡二叉树

    1.AVL树 带有平衡条件的二叉查找树,所以它必须满足条件: 1 是一棵二叉查找树 2 满足平衡条件 1.1 平衡条件: 1)严格的平衡条件:每个节点都必须有相同高度的左子树和右子树(过于严格而不被使 ...

  4. 红黑树与AVL(平衡二叉树)的区别

    关于红黑树和AVL树,来自网络: 1 好处 及 用途 红黑树 并不追求“完全平衡 ”——它只要求部分地达到平衡要求,降低了对旋转的要求,从而提高了性能. 红黑树能够以 O(log2  n)  的时间复 ...

  5. 数据结构与算法--从平衡二叉树(AVL)到红黑树

    数据结构与算法--从平衡二叉树(AVL)到红黑树 上节学习了二叉查找树.算法的性能取决于树的形状,而树的形状取决于插入键的顺序.在最好的情况下,n个结点的树是完全平衡的,如下图"最好情况&q ...

  6. 图解数据结构树之AVL树

    AVL树(平衡二叉树): AVL树本质上是一颗二叉查找树,但是它又具有以下特点:它是一棵空树或它的左右两个子树的高度差的绝对值不超过1,并且左右两个子树都是一棵平衡二叉树.在AVL树中任何节点的两个子 ...

  7. 单例模式,堆,BST,AVL树,红黑树

    单例模式 第一种(懒汉,线程不安全): public class Singleton { private static Singleton instance; private Singleton () ...

  8. BST AVL RBT B- B+ 的一些理解

    BST(二叉查找树,排序二叉树),如果数据有序的话,组成的二叉树会形成单列的形式,导致查询效率低AVL(平衡二叉树) 使树的左右高度差的绝对值不超过2,保证了查询效率.但是插入和删除会带来多次旋转,导 ...

  9. 【数据结构06】二叉平衡树(AVL树)

    目录 一.平衡二叉树定义 二.这货还是不是平衡二叉树? 三.平衡因子 四.如何保持平衡二叉树平衡? 五.平衡二叉树插入节点的四种情况 六.平衡二叉树操作的代码实现 七.AVL树总结 @ 一.平衡二叉树 ...

随机推荐

  1. bean的创建(五)第二部分 寻找bean的工厂方法实例化

    instanceWrapper = createBeanInstance(beanName, mbd, args); AbstractAutowireCapableBeanFactory.create ...

  2. DesignPattern系列__02接口隔离原则

    介绍 客户端不应该依赖它不需要的接口,即一个类对另一个类的依赖应该建立在最小接口上. Demo引入 先来看一张图: interface MyInterface { void operation1(); ...

  3. JavaScript数据结构——链表的实现与应用

    链表用来存储有序的元素集合,与数组不同,链表中的元素并非保存在连续的存储空间内,每个元素由一个存储元素本身的节点和一个指向下一个元素的指针构成.当要移动或删除元素时,只需要修改相应元素上的指针就可以了 ...

  4. main方法中注入Spring bean

    在有些情况下需要使用main使用Spring bean,但是main方法启动并没有托管给Spring管理,会导致bean失败,报空指针异常. 可以使用 ClassPathXmlApplicationC ...

  5. JavaFX Metro UI 和 开发库

    目录 [隐藏] 1 Metro UI For JavaFX! 1.1 例子 1.2 Switch 1.3 Button 1.4 案例: 2 ConsrolsFX 3 Notification 的使用 ...

  6. 转载 | 一种让超大banner图片不拉伸、全屏宽、居中显示的方法

    现在很多网站的Banner图片都是全屏宽度的,这样的网站看起来显得很大气.这种Banner一般都是做一张很大的图片,然后在不同分辨率下都是显示图片的中间部分.实现方法如下: <html> ...

  7. Java——数据结构(链表)

    链表,可扩展长度,泛型. public class Link { Node header = null; //头结点 int length;//当前链表长度 class Node { Node nex ...

  8. Flutter 1.7 正式版发布

    今天,我们非常高兴地向大家宣布又一个正式版本的发布 -- Flutter 1.7,这是继上次 I/O 时众多重要功能发布以来的一次小更新.Flutter 1.7 包含了对 AndroidX 的支持,满 ...

  9. flask项目部署到云服务器+域名绑定

    一.效果演示 首页展示 播放页面 该项目部署只为学习,所以用的服务器是腾讯云服务器10元/月,域名也是在腾讯云买的.com 55元/年  因为本人比较穷 哈哈

  10. 『深度应用』NLP机器翻译深度学习实战课程·零(基础概念)

    0.前言 深度学习用的有一年多了,最近开始NLP自然处理方面的研发.刚好趁着这个机会写一系列NLP机器翻译深度学习实战课程. 本系列课程将从原理讲解与数据处理深入到如何动手实践与应用部署,将包括以下内 ...