平衡二叉树基本操作的演示

可参考：https://blog.csdn.net/hnust_xiehonghao/article/details/7938869
https://blog.csdn.net/u010552731/article/details/47393549
https://github.com/zhaoxin111/AVLTree/blob/master/avltree.c
二、概要设计
1）平衡二叉树的旋转

avlTree
left_left_Rotation(avlTree T)

初始条件：二叉树T存在。

操作结果：实现LL旋转。

avlTree
right_right_Rotation(avlTree T)

初始条件：二叉树T存在。

操作结果：实现RR旋转。

avlTree
left_right_rotation(avlTree T)

初始条件：二叉树T存在。

操作结果：实现LR旋转。

avlTree
right_left_rotation(avlTree T)

初始条件：二叉树存在。

操作结果：实现RL旋转。

（2）平衡二叉树的插入

avlTree
insert_Node(ElementType x, avlTree T)

初始条件：二叉树T存在，需插入数据x。

操作结果：插入数据并且旋转。

（3）平衡二叉树的删除

avlTree
delete_Node(ElementType x, avlTree T)

初始条件：二叉树T存在，需删除数据x

操作结果：删除数据并且旋转。

（4）平衡二叉树的查询

int search(avlTree T, int data)

初始条件：二叉树T存在，需查询数据x

操作结果：输出查询成功与否的结果。

（5）平衡二叉树先序遍历

void
pre_order_avltree(avlTree tree)

初始条件：二叉树T存在。

操作结果：先序遍历输出T。

三、详细设计

#include<stdio.h>

#include<stdlib.h>

typedef int ElementType;

typedef struct Node {

ElementType data;

int height;//深度

struct Node *left, *right;

}avlNode, *avlTree;

int get_Height(avlTree N) {

if (!N)

    return 0;

else

    return N->height;

}

int max_Height(int x, int y) {

if (x > y)

    return x;

else

    return y;

}

void menu(){

printf("--------------1、插入数据--------------\n");

printf("--------------2、查找数据--------------\n");

printf("--------------3、删除数据--------------\n");

printf("--------------4、结束程序--------------\n");

}

int search(avlTree T, int data) {

if (T == NULL) {

    printf("不存在该数\n");

    return 0;

}

if (T->data == data) {

    printf("存在该数\n");

    return 0;

}

else if (data < T->data) {

    search(T->left, data);

}

else {

    search(T->right, data);

 }

}

avlTree left_left_Rotation(avlTree T) {

avlTree k2 = T->left;

T->left =k2->right;

k2->right= T;

T->height =max_Height(get_Height(T->left), get_Height(T->right)) + 1;

k2->height= max_Height(get_Height(k2->left), get_Height(k2->right) + 1);

return k2;

}

avlTree right_right_Rotation(avlTree T) {

avlNode *k3 = T->right;

T->right =k3->left;

k3->left= T;

T->height =max_Height(get_Height(T->left), get_Height(T->right)) + 1;

k3->height= max_Height(get_Height(k3->left), get_Height(k3->right)) + 1;

return k3;

}

avlTree left_right_rotation(avlTree T) {

T->left = right_right_Rotation(T->left);

T = left_left_Rotation(T);

return T;

}

avlTree right_left_rotation(avlTree T) {

T->right = left_left_Rotation(T->right);

T = left_right_rotation(T);

return T;

}

avlTree insert_Node(ElementType x, avlTree T) {

if (T==NULL) {

    T = (avlTree)malloc(sizeof(avlNode));

    T->left = NULL;

    T->right = NULL;

    T->height = 0;

    T->data = x;

}

else if (x < T->data) {

    T->left = insert_Node(x, T->left);

    if (get_Height(T->left) -get_Height(T->right) == 2) {

         if (x < (T->left)->data){

             T = left_left_Rotation(T);

         }

         else

             T = left_right_rotation(T);

    }

}

else if (x > T->data) {

    T->right =insert_Node(x, T->right);

    if (get_Height(T->right) -get_Height(T->left) == 2)

    {

         if (x > T->right->data)  {

             T =right_right_Rotation(T);

         }

         else  {

             T =right_left_rotation(T);

         }

    }

}

else {

    printf("不允许插入相同值结点\n");

}

T->height =max_Height(get_Height(T->left), get_Height(T->right)) + 1;

return T;

}

avlTree delete_Node(ElementType x, avlTree T) {

if (!T) {

    printf("ERROR\n");

    return NULL;

}

if (x < T->data)

    T->left =delete_Node(x, T->left);

else if (x > T->data)

    T->right =delete_Node(x, T->right);

else {

    if (T->left&&T->right) {

         avlTree temp = T->right;

         while (temp->left != NULL) {

             temp= temp->left;

         }

         T->data =temp->data;

         T->right =delete_Node(temp->data, T->right);

         if (get_Height(T->left) -get_Height(T->right) == 2) {

             if ((T->left->right!= NULL) &&get_Height(T->left->right)> get_Height(T->left->left))

                 left_left_Rotation(T);

             else

                 left_left_Rotation(T);

         }

    }

    else {

         avlTree temp = T;

         if (!T->left)

             T = T->right;

         else if (!T->right)

             T = T->left;

         free(temp);

    }

}

if (T) {

    T->height =max_Height(get_Height(T->left), get_Height(T->right));

}

return T;

}

void pre_order_avltree(avlTree tree){//先序遍历

if (tree){

    printf("%d ", tree->data);

    pre_order_avltree(tree->left);

    pre_order_avltree(tree->right);

}

}

int main()
{

avlTree root=NULL;

int num, n;

menu();

while (1) {

    printf("输入所选选项：");

    scanf_s("%d", &num);

    switch (num) {

    case 1:

         printf("请输入要插入的数据：");

         scanf_s("%d", &n);

         root=insert_Node(n,root);

         printf("先序遍历：");

         pre_order_avltree(root);

         printf("\n");

         menu();

         break;

    case 2:

         printf("请输入要查询的数据：");

         scanf_s("%d", &n);

         search(root,n);

         menu();

         break;

    case 3:

         printf("请输入要删除的数据：");

         scanf_s("%d", &n);

         root=delete_Node(n,root);

         printf("先序遍历：");

         pre_order_avltree(root);

         printf("\n");

         menu();

         break;

    case 4:

         return 0;

    }

}

return 0;

}