AVL平衡树

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;

typedef struct treeItem {
ElementType e;
struct treeItem *left;
struct treeItem *right;
} TreeItem;

typedef TreeItem *Tree;

#define MAX(a, b) ((a) > (b) ? (a) : (b))

TreeItem *Find(Tree t, ElementType e)
{
while (t != NULL && e != t->e) {
if (e < t->e)
t = t->left;
else/* if (e > t->e) */
t = t->right;
}

return t;
}

TreeItem *FindMin(Tree t)
{
while (t && t->left) {
t = t->left;
}

return t;
}

TreeItem *FindMax(Tree t)
{
while (t && t->right) {
t = t->right;
}

return t;
}

TreeItem *SingleRotateWithLeft(TreeItem *p1)
{
TreeItem *p2;

p2 = p1->left;
p1->left = p2->right;
p2->right = p1;

return p2;
}

TreeItem *SingleRotateWithRight(TreeItem *p1)
{
TreeItem *p2;

p2 = p1->right;
p1->right = p2->left;
p2->left = p1;

return p2;
}

TreeItem *DoubleRotateWithLeft(TreeItem *p1)
{
// Rotate between p2 and p3
// 	p1->left = SingleRotateWithRight(p1->left);
// 	// Rotate between p1 and p2
// 	return SingleRotateWithLeft(p1);

TreeItem *p2 = p1->left;
TreeItem *p3 = p2->right;

p2->right = p3->left; // R
p3->left = p2;
p1->left = p3;

p1->left = p3->right; // L
p3->right = p1;

return p3;
}

TreeItem *DoubleRotateWithRight(TreeItem *p1)
{
p1->right = SingleRotateWithLeft(p1->right);
return SingleRotateWithRight(p1);
}

Tree AVLInsert(Tree t, ElementType e)
{
if (t == NULL) {
t = (TreeItem *)malloc(sizeof(treeItem));
if (!t) {
printf("malloc error!\n");
return NULL;
}
t->e = e;
t->left = t->right = NULL;
} else if (e < t->e) {
t->left = AVLInsert(t->left, e);
if ((GetHeight(t->left) - GetHeight(t->right)) == 2) {
if (e < t->left->e)  // LL
t = SingleRotateWithLeft(t);
else
t = DoubleRotateWithLeft(t); // LR
}
} else { // e >= t->e
t->right = AVLInsert(t->right, e);
if ((GetHeight(t->right) - GetHeight(t->left)) == 2) {
if (e > t->right->e) // RR
t = SingleRotateWithRight(t);
else
t = DoubleRotateWithRight(t); // RL
}
}

return t;
}

Tree AVLDelete(Tree t, ElementType e)
{
if (!t) {
printf("t is empty!\n");
} else if (e < t->e) {
t->left = AVLDelete(t->left, e);
if (GetHeight(t->right) - GetHeight((t->left)) == 2) {
TreeItem *p = t->right;
if (GetHeight(p->left) > GetHeight(p->right))
t = DoubleRotateWithRight(t);
else
t = SingleRotateWithRight(t);
}
} else if (e > t->e) {
t->right = AVLDelete(t->right, e);
if (GetHeight(t->left) - GetHeight((t->right)) == 2) {
TreeItem *p = t->left;
if (GetHeight(p->right) > GetHeight(p->left))
t = DoubleRotateWithLeft(t);
else
t = SingleRotateWithLeft(t);
}
} else { // e = t->e // fount it
if (t->left && t->right) { // 有两个孩子的情况
if (GetHeight(t->left) > GetHeight(t->right)) {  // 这里处理是关键
t->e = FindMax(t->left)->e;
t->left = AVLDelete(t->left, t->e);
} else {
t->e = FindMin(t->right)->e;
t->right = AVLDelete(t->right, t->e);
}
} else { // 只有一个孩子or没有孩子
TreeItem *pe = t;
t = t->left ? t->left : t->right;
free(pe);
}
}
return t;
}

#define BUFSIZE 10

int main()
{
int arr[BUFSIZE] = {19, 13, 23, 8, 17, 21, 43, 3, 11, 14};
Tree t = NULL;

printf("insert element:\n");
for (int i = 0; i < BUFSIZE; i++) {
t = AVLInsert(t, arr[i]);
printf("height:%d\n", GetHeight(t));
InorderTraversal1(t);
printf("\n");
}

printf("delete element:\n");
for (int i = 0; i < BUFSIZE; i++) {
t = AVLDelete(t, arr[i]);
printf("height:%d\n", GetHeight(t));
InorderTraversal(t);
printf("\n");
}

getchar();
return 0;
}