二叉平衡查找树AvlTree（C实现）

二叉平衡查找树即是一棵树中所有节点的左右子树高度差不超过1的查找树

头文件——————————————————————————————

#ifndef _AVLTREE_H_

#define _AVLTREE_H_

#include <stdlib.h>

#include <iomanip>

#include <iostream>



typedef struct AvlNode *Position;

typedef Position AvlTree;

#define Element int

struct AvlNode

{

     Element data;

     int height;//叶子节点高度定义为0，其父节点为1以此类推

     AvlTree left;

     AvlTree right;

};



static int Height(AvlTree avl);

void SwapAvlNode(Position *p1, Position *p2);

Position GetNotBalancedNode(AvlTree avl);

void MakeEmpty(AvlTree* pavl);

Position Find(Element x, AvlTree avl);

Position FindMin(AvlTree avl);

Position FindMax(AvlTree avl);

void Insert(Element x, AvlTree* pavl);

void Delete(Element x, AvlTree* pavl);

Element Retrieve(Position p);

void SingleRotateWithLeftLeft(Position *pK2);

void SingleRotateWithRightRight(Position *pK2);

void DoubleRotateWithLeftRight(Position *pK3);

void DoubleRotateWithRightLeft(Position *pK3);

void PrintTree(AvlTree avl, int Depth, int ctrl);

#endif

源文件————————————————————————————————

#include "./AvlTree.h"



int Max(int a, int b)

{

     if(a <= b)

          return b;

     return a;

}

void SwapAvlNode(Position *p1, Position *p2)

{

     Position tmp = *p1;

     *p1 = *p2;

     *p2 = tmp;

}

int Abs(int a)

{

     if(a < 0) return -a;

     return a;

}

static int Height(AvlTree avl)

{

     if(NULL == avl)

          return -1;

     else

          return avl->height;

}

Position GetNotBalancedNode(AvlTree avl)

{

     if(NULL == avl)

          return NULL;

     else

     {

          if(Height(avl->left) - Height(avl->right) == Abs(2))//not balanced

               return avl;

          else

          {

               Position res = GetNotBalancedNode(avl->left);

               if(NULL != res)//avl->left is not balanced

                    return res;

               else

                    return GetNotBalancedNode(avl->right);

          }

     }

}

void MakeEmpty(AvlTree* pavl)

{

     if(NULL != (*pavl))

     {

          MakeEmpty(&((*pavl)->left));

          MakeEmpty(&((*pavl)->right));

          free(*pavl);

          *pavl = NULL;

     }

}

Position Find(Element x, AvlTree avl)

{

     Position pos = avl;

     while(NULL != pos)

     {

          if(x < Retrieve(pos))

               pos = pos->left;

          else if(x > Retrieve(pos))

               pos = pos->right;

          else

               break;

     }

     return pos;

}

Position FindMin(AvlTree avl)

{

     while(NULL != avl && NULL != avl->left)

          avl = avl->left;

     return avl;

}

Position FindMax(AvlTree avl)

{

     while(NULL != avl && NULL != avl->right)

          avl = avl->right;

     return avl;

}

void Insert(Element x, AvlTree* pavl)

{

     if(NULL == (*pavl))

     {

          Position tmp = (Position)malloc(sizeof(struct AvlNode));

          if(NULL == tmp)

               return ;

          tmp->data = x;

          tmp->height = 0;

          tmp->left = tmp->right = NULL;

          *pavl = tmp;

     }

     else

     {

          if(x < Retrieve(*pavl))//在*pavl的左儿子上插入

          {

               Insert(x, &((*pavl)->left));

               if(Height((*pavl)->left) - Height((*pavl)->right) == 2)//不平衡

               {

                    if(x < Retrieve((*pavl)->left))//左儿子的左子树

                         SingleRotateWithLeftLeft(pavl);

                    else//左儿子的右子树

                         DoubleRotateWithLeftRight(pavl);

               }

          }

          else if(x > Retrieve(*pavl))//在*pavl的右儿子上插入

          {

               Insert(x, &((*pavl)->right));

               if(Height((*pavl)->right) - Height((*pavl)->left) == 2)//不平衡

               {

                    if(x > Retrieve((*pavl)->right))//右儿子的右子树

                         SingleRotateWithRightRight(pavl);

                    else//右儿子的左子树

                         DoubleRotateWithRightLeft(pavl);

               }

          }

     }

     (*pavl)->height = Max(Height((*pavl)->left), Height((*pavl)->right)) + 1;

}

void Delete(Element x, AvlTree* pavl)

{

     if(NULL == *pavl)

          return ;

     if(x < Retrieve((*pavl)))//go left

          Delete(x, &((*pavl)->left));

     else if(x > Retrieve((*pavl)))//go right

          Delete(x, &((*pavl)->right));

     else if(NULL != (*pavl)->left && NULL != (*pavl)->right)//*pavl has two children

     {

          //利用右子树的最小值tmp->data来替代被删除的节点上的值x，然后在右子树上递归的删除值tmp->data

          Position tmp = FindMin((*pavl)->right);

          (*pavl)->data = tmp->data;

          Delete(tmp->data, &((*pavl)->right));

     }

     else//*pavl has none or one child

     {

          Position tmp = *pavl;

          if(NULL == (*pavl)->left)//*pavl has right child

               *pavl = (*pavl)->right;

          else if(NULL == (*pavl)->right)//*pavl has left child

               *pavl = (*pavl)->left;

          free(tmp);

     }

     if(NULL != *pavl)//最后更新*pavl节点上的高度

     {

          (*pavl)->height = Max(Height((*pavl)->left), Height((*pavl)->right)) + 1;

          if(2 == Height((*pavl)->left) - Height((*pavl)->right))//not balanced

          {

               if(NULL == (*pavl)->left->right)

                    SingleRotateWithLeftLeft(pavl);

               else

                    DoubleRotateWithLeftRight(pavl);

          }

          else if(2 == Height((*pavl)->right) - Height((*pavl)->left))//not balance

          {

               if(NULL == (*pavl)->right->left)

                    SingleRotateWithRightRight(pavl);

               else

                    DoubleRotateWithRightLeft(pavl);

          }

     }

}

Element Retrieve(Position p)

{

     return p->data;

}

void SingleRotateWithLeftLeft(Position *pK2)

{

     Position k2 = *pK2;

     Position k1 = k2->left;

     k2->left = k1->right;

     k1->right = k2;

     k1->height = Max(Height(k1->left), Height(k2)) + 1;

     k2->height = Max(Height(k2->left), Height(k2->right)) + 1;

     *pK2 = k1;

}

void SingleRotateWithRightRight(Position *pK2)

{

     Position k2 = *pK2;

     Position k1 = k2->right;

     k2->right = k1->left;

     k1->left = k2;

     k1->height = Max(Height(k2), Height(k1->right)) + 1;

     k2->height = Max(Height(k2->left), Height(k2->right)) + 1;

     *pK2 = k1;

}

void DoubleRotateWithLeftRight(Position *pK3)

{

     SingleRotateWithRightRight(&((*pK3)->left));

     SingleRotateWithLeftLeft(pK3);

}

void DoubleRotateWithRightLeft(Position *pK3)

{

     SingleRotateWithLeftLeft(&((*pK3)->right));

     SingleRotateWithRightRight(pK3);

}

void PrintTree(AvlTree avl, int Depth, int ctrl)//ctrl:0=root 1=left 2=right

{

    

     if(NULL != avl)

     {

          std::cout<<std::setw(Depth);

          if(0 == ctrl)

               std::cout<<"rt:";

          else if(1 == ctrl)

               std::cout<<"l";

          else if(2 == ctrl)

               std::cout<<"r";

          std::cout<<avl->data<<std::endl;

          PrintTree(avl->left, Depth+3, 1);

          PrintTree(avl->right, Depth+3, 2);

     }

}