AVL搜索树同时具有AVL树和搜索树的性质,相当于一种把高度控制在O(log n)的搜索树,从而保证了查找、插入、删除的时间都为O(log n)。
AVL树保证对于树中的任意节点,其两子树的高度之差不大于1,于是引入平衡因子这一概念。平衡因子表示一个节点的左子树的高度减去右子树的高度。也就是说,正常的AVL搜索树的任一节点,其平衡因子为1,0或-1,而当插入或删除了节点之后,树中出现某些节点平衡因子可能会变为2或-2,此时需要调整树的平衡。
现在假设节点nodeX是距离插入/删除位置最近、且平衡因子为2或-2的节点(之所以考察距离插入/删除位置最近的失衡节点,是因为其他失衡节点可能会在这个节点恢复平衡之后再次发生改变,这就体现出AVL搜索树调整平衡要“自下而上”)。此时共有四种可能的情况:
(1)nodeX的平衡因子为2,nodeX的左子树的平衡因子为1;
(2)nodeX的平衡因子为-2,nodeX的右子树的平衡因子为-1;
(3)nodeX的平衡因子为2,nodeX的左子树的平衡因子为-1或0;
(4)nodeX的平衡因子为-2,nodeX的右子树的平衡因子为1或0。
其中(1)(2)互相对称,(3)(4)互相对称。当且仅当删除操作的时候会出现子树平衡因子为0的情况。
情况(1),对nodeX使用一次右旋转可恢复平衡;
情况(2),对nodeX使用一次左旋转可恢复平衡;
情况(3),先对nodeX的左子树使用一次左旋转,再对nodeX使用一次右旋转可恢复平衡;
情况(4),先对nodeX的右子树使用一次右旋转,再对nodeX使用一次左旋转可恢复平衡。
(关于左旋转、右旋转,请看以下代码)
代码
本代码是在之前博文[C++]搜索树 查找/插入/删除的代码的基础上修改并且参考AVL树简介得到的。
不过关键的两个函数:插入和删除,都已经与之前搜索树的代码相去甚远,由以while循环为主体的函数转变为递归函数。虽然两者都能够查找到需要插入/删除的位置,但插入/删除完成之后需要自下而上调整树的平衡,while循环似乎很难从发生改变的位置向上回溯到整个树的根节点,而递归函数则可以在到达递归终点之后,回归到根节点,于是可以通过回归实现自下而上调整平衡。
using namespace std;
template<class T, class E>
struct bsNode//定义搜索树节点
{
pair<T, E> element;//元素为数对,前项表示关键字,后项表示数值
bsNode<T, E>* leftChild;//左子节点指针
bsNode<T, E>* rightChild;//右子节点指针
int height;//节点高度,用于计算父节点平衡因子
bsNode(const pair<T, E>& theElement)
{
element = theElement;
leftChild = NULL;
rightChild = NULL;
height = 0;
}
bsNode(const pair<T, E>& theElement, bsNode<T, E>* LEFT, bsNode<T, E>* RIGHT)
{
element = theElement;
leftChild = LEFT;
rightChild = RIGHT;
height = max(getHeight(LEFT),getHeight(RIGHT)) + 1;
}
};
template<class T, class E>
int getHeight(bsNode<T, E>* node)//获得某一节点下二叉树的高度
{
if (node == nullptr)
return 0;
int leftHeight = getHeight(node->leftChild);
int rightHeight = getHeight(node->rightChild);
return (max(leftHeight, rightHeight) + 1);
}
template<class T, class E>
class bsTree//AVL搜索树
{
public:
bsTree() { root = NULL; }
void ascend()//按关键字顺序输出元素数值
{
inOrder(root);
cout << endl;
}
void find(const T& theKey)//按关键字查找对应元素的数值
{
bsNode<T, E>* p = root;
while (p != NULL)
{
if (theKey < p->element.first)
p = p->leftChild;
else if (theKey > p->element.first)
p = p->rightChild;
else
{
cout << p->element.second << endl;
return;
}
}
cout << "Not find" << endl;
}
void insert(const pair<T, E>& theElement) { root = insert(root, theElement); }//插入节点,具体方法已被封装
void erase(const pair<T, E>& theElement) { root = erase(root, theElement); }//删除节点,具体方法已被封装
private:
bsNode<T, E>* root;
void inOrder(bsNode<T, E>* node)//中序遍历
{
if (node != nullptr)
{
inOrder(node->leftChild);
cout << node->element.second << " ";
inOrder(node->rightChild);
}
}
//以下为恢复AVL树平衡所需要的旋转函数
bsNode<T, E>* leftRotation(bsNode<T, E>* nodeX)//单左旋
{
bsNode<T, E>* X_right = nodeX->rightChild;
nodeX->rightChild = X_right->leftChild;
X_right->leftChild = nodeX;
nodeX->height = getHeight(nodeX);
X_right->height = getHeight(X_right);
return X_right;
}
bsNode<T, E>* rightRotation(bsNode<T, E>* nodeX)//单右旋
{
bsNode<T, E>* X_left = nodeX->leftChild;
nodeX->leftChild = X_left->rightChild;
X_left->rightChild = nodeX;
nodeX->height = getHeight(nodeX);
X_left->height = getHeight(X_left);
return X_left;
}
bsNode<T, E>* rightLeftRotation(bsNode<T, E>* nodeX)//先右旋,后左旋
{
nodeX->rightChild = rightRotation(nodeX->rightChild);
return leftRotation(nodeX);
}
bsNode<T, E>* leftRightRotation(bsNode<T, E>* nodeX)//先左旋,后右旋
{
nodeX->leftChild = leftRotation(nodeX->leftChild);
return rightRotation(nodeX);
}
//插入
bsNode<T, E>* insert(bsNode<T, E>*& node, const pair<T, E>& theElement)//递归找到插入位置,插入节点,然后自下而上调整平衡
{
if (node == NULL)//到达插入位置
node = new bsNode<T, E>(theElement);
else if (theElement.first > node->element.first)//向右走
{
node->rightChild = insert(node->rightChild, theElement);
if (getHeight(node->leftChild)-getHeight(node->rightChild) <- 1)//此时node平衡因子为-2
{
if (theElement.first > node->rightChild->element.first)//RR,单左旋
node = leftRotation(node);
else if (theElement.first < node->rightChild->element.first)//RL,先右旋后左旋
node = rightLeftRotation(node);
}
}
else if (theElement.first < node->element.first)//向左走
{
node->leftChild = insert(node->leftChild, theElement);
if (getHeight(node->leftChild) - getHeight(node->rightChild) > 1)//此时node平衡因子为2
{
if (theElement.first < node->leftChild->element.first)//LL,单右旋
node = rightRotation(node);
else if (theElement.first > node->leftChild->element.first)//LR,先左旋后右旋
node = leftRightRotation(node);
}
}
return node;
}
//删除
bsNode<T, E>* erase(bsNode<T, E>*& node, const pair<T, E>& theElement)//递归查找删除位置,删除节点,然后自下而上调整平衡
{
if (node != NULL)
{
if (theElement.first == node->element.first)//找到了需要删除的节点
{
if (node->leftChild != NULL && node->rightChild != NULL)//如果这个节点有两个子树,则需要化为删除其左子树最大值或右子树最小值
{
if (node->leftChild->height > node->rightChild->height)//当删除节点的左子树高于右子树时,删除左子树最大值
{
//找到左子树最大值,把它复制到删除节点上
bsNode<T, E>* leftMax = node->leftChild;
while (leftMax->rightChild != NULL)
leftMax = leftMax->rightChild;
node->element = leftMax->element;
node->leftChild = erase(node->leftChild, leftMax->element);
}
else//否则删除右子树最小值
{
//找到右子树最小值,把它复制到删除节点上
bsNode<T, E>* rightMin = node->rightChild;
while (rightMin->leftChild != NULL)
rightMin = rightMin->leftChild;
node->element = rightMin->element;
node->rightChild = erase(node->rightChild, rightMin->element);
}
}
else//如果删除节点只有至多一个子树,则将子树移动到删除节点位置上即可
{
bsNode<T, E>* deleteNode = node;
if (node->leftChild != NULL)
node = node->leftChild;
else
node = node->rightChild;
delete deleteNode;
}
}
else if (theElement.first > node->element.first)//向右走
{
node->rightChild = erase(node->rightChild, theElement);
if (getHeight(node->leftChild) - getHeight(node->rightChild) > 1)//此时node的平衡因子为2
{
if (getHeight(node->leftChild->leftChild) > getHeight(node->leftChild->rightChild))//node的左子树平衡因子为1,node单右旋
node = rightRotation(node);
else//node的左子树平衡因子为-1,node先左旋后右旋
node = leftRightRotation(node);
}
}
else if (theElement.first < node->element.first)//向左走
{
node->leftChild = erase(node->leftChild, theElement);
if (getHeight(node->leftChild) - getHeight(node->rightChild) < -1)//此时node的平衡因子为-2
{
if (getHeight(node->rightChild->rightChild) > getHeight(node->rightChild->leftChild))//node的右子树平衡因子为-1,node单左旋
node = leftRotation(node);
else//node的右子树平衡因子为-1,node先右旋后左旋
node = rightLeftRotation(node);
}
}
return node;
}
return NULL;
}
};