Geeks - AVL Tree Deletion 平衡二叉树 删除操作

注意：

1 判断一个节点是否平衡的方法

2 平衡一个节点的方法 ：

我这里比原文改进一点，独立出一个平衡节点的函数balanceNode()，这样一个函数可以用来平衡插入和删除操作，使得代码更加简洁了。

这样修改之后就使得平衡二叉树好像和一般二叉树的操作比较，就是多了一个平衡操作。

3 删除操作情况很多，很困难，一定要理清思路。十分容易出bug的地方。

这里是查找后继节点的值，填补上到需要删除的节点，然后删除后继节点，然后从后继节点往上判断，一个一个节点做平衡操作。

原文参考：http://www.geeksforgeeks.org/avl-tree-set-2-deletion/

#pragma once
#include <stdio.h>
#include <algorithm>

using std::max;

class AVL_Deletion
{
struct Node
{
int key;
Node *left, *right;
int h;
Node(int k) : key(k), left(NULL), right(NULL), h(1) {}
~Node()
{
if (left) delete left;
if (right) delete right;
}
};

void updateHeight(Node *n)
{
n->h = max(getHeight(n->left), getHeight(n->right)) + 1;
}

int getHeight(Node *n)
{
if (!n) return 0;
return n->h;
}

Node *leftRotate(Node *y)
{
Node *x = y->right;
y->right = x->left;
x->left = y;

updateHeight(y);
updateHeight(x);
return x;
}

Node *rightRotate(Node *y)
{
Node *x = y->left;
y->left = x->right;
x->right = y;

updateHeight(y);
updateHeight(x);
return x;
}

int getBalance(Node *n)
{
if (!n) return 0;
return getHeight(n->left) - getHeight(n->right);
}

Node *balanceNode(Node *n)
{
if (!n) return n;

updateHeight(n);

int balance = getBalance(n);

if (balance > 1 && getBalance(n->left) >= 0)
return rightRotate(n);
if (balance < -1 && getBalance(n->right) <= 0)
return leftRotate(n);
if (balance > 1 && getBalance(n->left) < 0)
{
n->left = leftRotate(n->left);
return rightRotate(n);
}
if (balance < -1 && getBalance(n->right) > 0)
{
n->right = rightRotate(n->right);
return leftRotate(n);
}
return n;
}

Node *insert(Node *n, int key)
{
if (!n) return new Node(key);

if (key < n->key) n->left = insert(n->left, key);
else n->right = insert(n->right, key);

return balanceNode(n);
}

Node *minValueNode(Node *n)
{
if (!n) return n;
Node *cur = n;
while (cur->left) cur = cur->left;
return cur;
}

Node *delNode(Node *r, int key)
{
if (!r) return r;

if (key < r->key) r->left = delNode(r->left, key);
else if (r->key < key) r->right = delNode(r->right, key);
else
{
if (!r->left || !r->right)
{
Node *t = r->left? r->left : r->right;
if (!t)
{
t = r;
r = NULL;
}
else *r = *t;//copy content, be careful about the *
free(t);
}
else
{
//key step: get inorder successor
Node *t = minValueNode(r->right);
r->key = t->key;
r->right = delNode(r->right, t->key);
}
}
return balanceNode(r);
}

void preOrder(Node *root)
{
if(root != NULL)
{
printf("%d ", root->key);
preOrder(root->left);
preOrder(root->right);
}
}
public:
AVL_Deletion()
{
Node *root = NULL;

/* Constructing tree given in the above figure */
root = insert(root, 9);
root = insert(root, 5);
root = insert(root, 10);
root = insert(root, 0);
root = insert(root, 6);
root = insert(root, 11);
root = insert(root, -1);
root = insert(root, 1);
root = insert(root, 2);

/* The constructed AVL Tree would be
9
/ \
1 10
/ \ \
0 5 11
/ / \
-1 2 6
*/

printf("Pre order traversal of the constructed AVL tree is \n");
preOrder(root);

root = delNode(root, 10);

/* The AVL Tree after deletion of 10
1
/ \
0 9
/ / \
-1 5 11
/ \
2 6
*/

printf("\nPre order traversal after deletion of 10 \n");
preOrder(root);
}
};