（转）AVL树的插入_删除操作

最新推荐文章于 2023-12-08 18:59:34 发布
最新推荐文章于 2023-12-08 18:59:34 发布
阅读量1.2k 收藏
点赞数
分类专栏： 算法 文章标签： null input insert delete struct output

版本1：

 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <assert.h>

typedef struct node node;

struct node
{
  node* parent;
  node* left;
  node* right;
  int   balance;  //左右子树高度之差
  int   key;
};

extern void traverseAVL1(node* root); //中序遍历, 下面定义

extern void traverseAVL2(node* root); //前序遍历, 下面定义

int searchNode(int key, node* root, node** parent) //按key查找结点
{
  node* temp;
  assert(root != NULL);
  temp = root;
  *parent = root->parent;
  while (temp !=NULL)
  {
    if (temp->key == key)
      return 1;
    else
    {
       *parent = temp;
      if (temp->key > key)
        temp = temp->left;
      else 
        temp = temp->right;
    }
  }
  return 0;

}

node* minNode(node* root) //树root的最小结点
{
  if (root == NULL)
    return NULL;
  while (root->left != NULL)
    root = root->left;
  return root;
}

node* maxNode(node* root) //树root的最大结点
{
  if (root == NULL)
    return NULL;
  while (root->right != NULL)
    root = root->right;
  return root;
}

node* preNode(node* target) //求前驱结点
{
  if (target == NULL)
    return NULL;
  if (target->left != NULL)
    return maxNode(target->left);
  else
    while ((target->parent!=NULL) && (target!=target->parent->right))
      target = target->parent;
  return target->parent;
}

node* nextNode(node* target) //求后继结点
{
  if (target == NULL)
    return NULL;
  if (target->right != NULL)
    return minNode(target->right);
  else
    while ((target->parent!=NULL) && (target!=target->parent->left))
      target = target->parent;
  return target->parent;
}

node* adjustAVL(node* root, node* parent, node* child)
{
  node *cur;
  assert((parent != NULL)&&(child != NULL));
  switch (parent->balance)
  {
  case 2:
    if (child->balance == -1)//LR型
    {
      cur = child->right;
      cur->parent = parent->parent;
      child->right = cur->left;
      if (cur->left != NULL)
        cur->left->parent = child;
      parent->left = cur->right;
      if (cur->right != NULL)
        cur->right->parent = parent;
      cur->left = child;
      child->parent = cur;
      cur->right = parent;
      if (parent->parent != NULL)
        if (parent->parent->left == parent)
          parent->parent->left = cur;
        else parent->parent->right = cur;
      else
        root = cur;
      parent->parent = cur;
      if (cur->balance == 0)
      {
        parent->balance = 0;
        child->balance = 0;
      }
      else if (cur->balance == -1)
      {
        parent->balance = 0;
        child->balance = 1;
      }
      else
      {
        parent->balance = -1;
        child->balance = 0;
      }
      cur->balance = 0;
    }
    else //LL型
    {
      child->parent = parent->parent;
      parent->left = child->right;
      if (child->right != NULL)
        child->right->parent = parent;
      child->right = parent;
      if (parent->parent != NULL)
        if (parent->parent->left == parent)
          parent->parent->left = child;
        else parent->parent->right = child;
      else
        root = child;
      parent->parent = child;
      if (child->balance == 1) //插入时
      {
        child->balance = 0;
        parent->balance = 0;
      }
      else //删除时
      {
        child->balance = -1;
        parent->balance = 1;
      }
    }
   break;
   
  case -2:
    if (child->balance == 1) //RL型
    {
      cur = child->left;
      cur->parent = parent->parent;
      child->left = cur->right;
      if (cur->right != NULL)
        cur->right->parent = child;
      parent->right = cur->left;
      if (cur->left != NULL)
        cur->left->parent = parent;
      cur->left = parent;
      cur->right = child;
      child->parent = cur;
      if (parent->parent != NULL)
        if (parent->parent->left == parent)
          parent->parent->left = cur;
        else parent->parent->right = cur;
      else
        root = cur;
      parent->parent = cur;
      if (cur->balance == 0)
      {
        parent->balance = 0;
        child->balance = 0;
      }
      else if (cur->balance == 1)
      {
        parent->balance = 0;
        child->balance = -1;
      }
      else
      {
        parent->balance = 1;
        child->balance = 0;
      }
      cur->balance = 0;
    }
    else  //RR型
    {
      child->parent = parent->parent;
      parent->right = child->left;
      if (child->left != NULL)
        child->left->parent = parent;
      child->left = parent;
      if (parent->parent != NULL)
        if (parent->parent->left == parent)
          parent->parent->left = child;
        else parent->parent->right = child;
      else
        root = child;
      parent->parent = child;
      if (child->balance == -1) //插入时
      {
        child->balance = 0;
        parent->balance = 0;
      }
      else //删除时
      {
        child->balance = 1;
        parent->balance = -1;
      }
    }
    break;
  }
  return root;
}


node* insertNode(int key, node* root)
{
  node *parent, *cur, *child;
  assert (root != NULL);
  if (searchNode(key, root, &parent)) //结点已存在
    return root;
  else
  {
    cur = (node*)malloc(sizeof(node));
    cur->parent = parent;
    cur->key = key;
    cur->left = NULL;
    cur->right = NULL;
    cur->balance = 0;
    if (key<parent->key)
    {
      parent->left = cur;
      child = parent->left;
    }
    else
    {
      parent->right = cur;
      child = parent->right;
    }
    
    while ((parent != NULL)) //查找需要调整的最小子树
    {
      if (child == parent->left)
        if (parent->balance == -1)
        {
          parent->balance = 0;
          return root;
        }
        else if (parent->balance == 1)
        {
          parent->balance = 2;
          break;
        }
        else
        {
          parent->balance = 1;
          child = parent;
          parent = parent->parent;
        }
      else if (parent->balance == 1)
      {
        parent->balance = 0;
        return root;
      }
      else if (parent->balance == -1)
      {
        parent->balance = -2;
        break;
      }
      else 
      {
        parent->balance = -1;
        child = parent;
        parent = parent->parent;
      }
    }
    
    if (parent == NULL)
      return root;
    return adjustAVL(root, parent, child);
  }
}

node* deleteNode(int key, node* root)
{
  node *dNode, *parent, *child, *tp;
  int temp, tc;
  assert(root!=NULL);
  if (!searchNode(key, root, &parent))
    return root;
  else
  {
    if (parent == NULL)
      dNode = root;
    else if ((parent->left!=NULL)&&(parent->left->key==key))
      dNode = parent->left;
    else dNode = parent->right;

    child = dNode;
    while ((child->left!=NULL)||(child->right!=NULL)) //确定需要删除的结点
    {
      if (child->balance == 1)
        child = preNode(dNode);
      else child = nextNode(dNode);
      temp = child->key;
      child->key = dNode->key;
      dNode->key = temp;
      dNode = child;
    }
   
    child = dNode;
    parent = dNode->parent;
      
    while ((parent != NULL)) //查找需要调整的最小子树
    {
      if (child == parent->left)
        if (parent->balance == 1)
        {
          parent->balance = 0;
          child = parent;
          parent = parent->parent;
        }
        else if (parent->balance == -1)
        {
          parent->balance = -2;
          child = parent->right;
          temp = parent->right->balance;//临时变量保存
          tp = parent->parent;//临时变量保存
          if (tp != NULL)
            if (parent == tp->left)
              tc = 1;
            else tc = -1;
          else tc = 0;
          
          root = adjustAVL(root, parent, child);
         
          if (temp == 0)
            break;
          else
          {
            if (tc == 1)
              child = tp->left;
            else if (tc == -1)
              child = tp->right;
            parent = tp;
          }

        }
        else
        {
          parent->balance = -1;
          break;
        }
      else if (parent->balance == -1)
      {
        parent->balance = 0;
        child = parent;
        parent = parent->parent;
      }
      else if (parent->balance == 1)
      {
        parent->balance = 2;
        child = parent->left;
        temp = parent->left->balance;//临时变量保存
        tp = parent->parent;//临时变量保存
        if (tp != NULL)
          if (parent == tp->left)
            tc = 1;
          else tc = -1;
        else tc = 0;
        
        root = adjustAVL(root, parent, child);
        
        if (temp == 0)
          break;
        else
        {
          if (tc == 1)
            child = tp->left;
          else if (tc == -1)
            child = tp->right;
          parent = tp;
        }
      }
      else
      {
        parent->balance = 1;
        break;
      }
    }
    
    if (dNode->parent != NULL)
      if (dNode == dNode->parent->left)
        dNode->parent->left = NULL;
      else dNode->parent->right = NULL;
    free(dNode);
    if (root == dNode)
      root = NULL; //root被删除, 避免野指针
    dNode = NULL;
    
    return root;
  }
}


node* createAVL(int *data, int size)
{
  int i, j;
  node *root;
  if (size<1)
    return NULL;
  root = (node*)malloc(sizeof(node));
  root->parent = NULL;
  root->left = NULL;
  root->right = NULL;
  root->key = data[0];
  root->balance = 0;
  
  for(i=1;i<size;i++)
    root = insertNode(data[i], root);
  return root;
}

void destroyAVL(node* root)
{
  if (root != NULL)
  {
    destroyAVL(root->left);
    destroyAVL(root->right);
    free(root);
    root=NULL;
  }
  
}

void traverseAVL1(node* root) //中序遍历
{
  if (root != NULL)
  {
    traverseAVL1(root->left);
    printf("%d, %d\n", root->key, root->balance);
    traverseAVL1(root->right);
  }
}

void traverseAVL2(node* root) //先序遍历
{
  if (root != NULL)
  {
    printf("%d, %d\n", root->key, root->balance);
    traverseAVL2(root->left);
    traverseAVL2(root->right);
  }
}

int main(int argc, char *argv[])
{
  int data[] = {1, 5, 7, 4, 3, 2, 11, 9, 10};
  node* root;
  root = createAVL(data, sizeof(data)/sizeof(data[0]));

  printf("++++++++++++++++++++++++++++\n");
  traverseAVL1(root);
  printf("\n");
  traverseAVL2(root);
  
  root = deleteNode(5, root);
  printf("++++++++++++++++++++++++++++\n");
  traverseAVL1(root);
  printf("\n");
  traverseAVL2(root);

  root = deleteNode(3, root);
  printf("++++++++++++++++++++++++++++\n");
  traverseAVL1(root);
  printf("\n");
  traverseAVL2(root);

  root = deleteNode(1, root);
  printf("++++++++++++++++++++++++++++\n");
  traverseAVL1(root);
  printf("\n");
  traverseAVL2(root);

  root = deleteNode(7, root);
  printf("++++++++++++++++++++++++++++\n");
  traverseAVL1(root);
  printf("\n");
  traverseAVL2(root);

  root = deleteNode(4, root);
  printf("++++++++++++++++++++++++++++\n");
  traverseAVL1(root);
  printf("\n");
  traverseAVL2(root);

  root = deleteNode(2, root);
  printf("++++++++++++++++++++++++++++\n");
  traverseAVL1(root);
  printf("\n");
  traverseAVL2(root);

  destroyAVL(root);
}


 

版本2：

#include <stdio .h>
#include <stdbool .h>
#include <stdlib .h>
 
char chos;
int input;
bool unbalanced = false;
struct node{
    int data;
    int bf;
    node *lchild;
    node *rchild;
};
typedef struct node *BST;
BST R = NULL;
 
void Chose(){
    printf("i) Insert a point\n"
           "d) Delete a point\n"
           "e) exit\n"
           "Input your choose:");
    scanf(" %c", &chos);
}

int Height(BST T){     /*返回当前节点的高度*/
    if(T == NULL)
        return -1;
    else
        return T->bf;
}

int Max(int A, int B){
    return ((A > B) ? A:B);
}

BST SingleRotateWithRight(BST K2){          /*RR型旋转*/
    BST K1;
    K1 = K2->rchild;
    K2->rchild = K1->lchild;
    K1->lchild = K2;
    K2->bf = Max(Height(K2->lchild), Height(K2->rchild)) + 1;
    K1->bf = Max(Height(K1->lchild), Height(K1->rchild)) + 1;
    return K1;
}

BST SingleRotateWithLeft(BST K2){           /*LL型旋转*/
    BST K1;
    K1 = K2->lchild;
    K2->lchild = K1->rchild;
    K1->rchild = K2;
    K2->bf = Max(Height(K2->lchild), Height(K2->rchild)) + 1;
    K1->bf = Max(Height(K1->lchild), Height(K1->rchild)) + 1;
    return K1;
}

BST DoubleRotateWithLeft(BST K3){           /*LR = RR(K3->lchild) + LL（K3）*/
    K3->lchild = SingleRotateWithRight(K3->lchild);
    return SingleRotateWithLeft(K3);
}

BST DoubleRotateWithRight(BST K3){          /*LL = LL(K3->lchild) + RR(K3)*/
    K3->rchild = SingleRotateWithLeft(K3->rchild);
    return SingleRotateWithRight(K3);
}

void OUT(BST T){                /*树的输出递归函数*/
    if(T->lchild){
        printf("Left\t%d\t[parent:%d]\n", T->lchild->data, T->data);
        OUT(T->lchild);
    }
    if(T->rchild){
        printf("Right\t%d\t[parent:%d]\n", T->rchild->data, T->data);
        OUT(T->rchild);
    }
}

BST Rotate(BST T){              /*对于单个节点进行的AVL调整*/
    if(Height(T->lchild) - Height(T->rchild) == 2){
        if(Height(T->lchild->lchild) >= Height(T->lchild->rchild)){
            T = SingleRotateWithLeft(T);
        }
        else{
            T = DoubleRotateWithLeft(T);
        }
    }
    if(Height(T->rchild) - Height(T->lchild) ==2){
        if(Height(T->rchild->rchild) >= Height(T->rchild->lchild)){
            T = SingleRotateWithRight(T);
        }
        else{
            T = DoubleRotateWithRight(T);
        }
    }
    return T;
}

BST AVLInsert(BST T){           /*AVL数的插入操作*/
    if(T == NULL){
        T = (BST)malloc(sizeof(struct node));
        T->data = input;
        T->lchild = T->rchild = NULL;
        T->bf = 0;
    }
    else if(input < T->data){
        T->lchild = AVLInsert(T->lchild);
        if(Height(T->lchild) - Height(T->rchild) == 2){
            if(input < T->lchild->data){
                T = SingleRotateWithLeft(T);            /*LL旋转*/
            }
            else{
                T = DoubleRotateWithLeft(T);            /*LR旋转*/
            }
        }
    }
    else if(input > T->data){
        T->rchild = AVLInsert(T->rchild);
        if(Height(T->rchild) - Height(T->lchild) == 2){
            if(input > T->rchild->data){
                T = SingleRotateWithRight(T);           /*RR旋转*/
            }
            else{
                T = DoubleRotateWithRight(T);           /*RL旋转*/
            }
        }
    }
    T->bf = Max(Height(T->lchild), Height(T->rchild)) + 1;
    return T;
}

void Output(BST T){
    if(T == NULL){
        printf("None\n");
    }
    else{
        printf("%d\troot\n", T->data);
        OUT(T);
    }
}

void Insert(){
    printf("\nInput the point your want to Insert: ");
    scanf("%d", &input);
    R = AVLInsert(R);
    Output(R);
}

BST AVLDelete(BST T, int key){
    if(T == NULL)
        return NULL;
    if(key == T->data){
        if(T->rchild == NULL){          /*如果T得右儿子为空则直接删除*/
            BST temp = T;
            T = T->lchild;
            free(temp);
        }
        else{                           /*否则找到T->rchild的最左儿子代替T*/
            BST temp = T->rchild;
            while(temp->lchild != NULL){
                temp = temp->lchild;
            }
            T->data = temp->data;
            T->rchild = AVLDelete(T->rchild, temp->data);      /*对于替代后的T及其各个子节点进行一些列调整，正到再次递归到T->rchild的最左儿子，删除它*/
            T->bf = Max(Height(T->lchild), Height(T->rchild)) + 1;
        }
        return T;
    }
    else if(key < T->data){
        T->lchild = AVLDelete(T->lchild, key);
    }
    else{
        T->rchild = AVLDelete(T->rchild, key);
    }
    T->bf = Max(Height(T->lchild), Height(T->rchild)) + 1;
    if(T->lchild != NULL){
        T->lchild = Rotate(T->lchild);
    }
    if(T->rchild != NULL){
        T->rchild = Rotate(T->rchild);
    }
    T = Rotate(T);
    return T;
}

void Delete(){
    printf("\nInput the point you want to Delete: ");
    scanf("%d", &input);
    R = AVLDelete(R, input);
    Output(R);
}

int main(){
    while(1){
        Chose();
        switch(chos){
            case 'i':
                Insert();
                break;
            case 'd':
                Delete();
                break;
            case 'e':
                exit(0);
        }
    }
    return 0;
}


 

软件真理与光
关注
专栏目录
AVL树的删除
dong18292000671的博客
05-29 389
AVL数的删除前面的操作和二叉搜索树的删除操作相同，只是在删除时顺便修改pParent的平衡因子，在删除完后，根据pParent的平衡因子，向上调整平衡因子直到平衡。 当pParent->_bf == 0时，需要向上调整； 当pParent->_bf == 1时，不需要修改，直接退出即可； 当pParent->_bf == 2时，需要进行左旋或右旋。bool Destory(const K&
AVL树的插入_删除操作实现~
作一个独立连续的思考者
08-08 8711
AVL的插入操作：找到所插位置之后，往上寻找可能发生不平衡之处x，若找到x则调整平衡。顶多调整平衡1次。 AVL的删除操作：找到删除结点x，类似于二叉查找树一样找到其后继或前驱y，若为x->right为NULL，y=x->lchild / x->rchild；否则找到x的后继，
平衡二叉树之AVL树
横扫天下的博客
04-24 607
平衡二叉树之AVL树简介 之前有篇文章讲二叉排序树（动态查找二叉排序树 ），二叉排序树是用于动态查找的数据结构，但在文章结尾中也说明了普通的二叉排序树的查找效率是不确定的，这主要取决于二叉排序树是否平衡，为了充分发挥二叉排序树的查找效率我们通常使用平衡的二叉排序树——平衡二叉树，常用的平衡二叉树主要有两种——AVL树和红黑树。今天我们主要介绍AVL树。 简介 AVL树的平衡条件为：其每个节点的左子...
数据结构——平衡二叉树
qq_42106610的博客
11-18 477
AVL树定义、性质以及相关操作。递归比较容易实现，非递归比较麻烦。已报劝退之仇。
平衡二叉树
XY67724907的博客
06-27 166
平衡二叉树 #include<stdlib.h> #include<stdio.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #defi...
【C++】AVL树插入删除
fight_p的博客
12-08 1788
这是一篇深度剖析AVL的插入，删除，以及判断是否是AVL树为主体的内容，其中涉及到LL，RR，LR，RL旋转的详细讲解。并且这是用的三叉实现的AVL树。
AVL树的 插入 和 删除
潜心钻研技术
03-11 2074
AVL树的 插入 和 删除
AVL.rar_AVL删除_avl 旋转_avl.sln_二叉树旋转_树 旋转
09-21
它的重要特性是任何节点的两个子树的高度最大差别不超过1，这使得AVL树在插入和删除操作后能够快速恢复平衡，从而保证了查找、插入和删除操作的平均时间复杂度为O(log n)。 一、AVL树的插入操作 在AVL树中插入一个...
avl.rar_AVL树_avl 旋转_树 旋转
09-24
AVL树的特点是任何节点的两个子树的高度差不超过1，这使得AVL树在插入和删除操作后能够快速恢复平衡，从而保证了查找、插入和删除操作的平均时间复杂度为O(log n)。 在AVL树中，有四种基本的旋转操作用于维护树的...
AVL_tree.zip_AVL树_avl_tree_avl树左右子树_平衡树_高度平衡树
09-21
这使得AVL树在查找、插入和删除操作上的性能非常稳定，时间复杂度接近于O(log n)。 AVL树的基本操作包括： 1. **查找**：在AVL树中查找元素遵循二叉查找树的规则，即从根节点开始，如果待查找元素小于当前节点，则...
avl.zip_1到n的avl图_avl树插入数字
09-21
在这个"avl.zip_1到n的avl图_avl树插入数字"的压缩包中，用户可以输入一个整数N，程序会生成一棵包含了从1到N所有数字的AVL树，并输出该树的前序遍历和后序遍历的结果。这两种遍历方式是理解AVL树结构的重要工具。 ...
AVL-tree.zip_AVL高效实现_avl 旋转_二叉树旋转_树 旋转
09-19
它的主要特性是任何节点的两个子树的高度差不超过1，这使得AVL树在插入、删除和查找操作上的效率相对较高，因为其保持了较好的平衡状态。在本资料包中，"AVL tree"文件包含了关于AVL树高效实现和旋转的详细内容。 ...
2021-09-05 基于map-set 平衡搜索树（平衡因子）
under_control的博客
09-05 83
//红黑树 //AVL树 平衡的二叉搜索树 //平衡因子 每个节点的左右子树的高度差 template struct AVLTreeNode { AVLTreeNode<T>* _Left; // 该节点的左孩子 AVLTreeNode<T>* _Right; // 该节点的右孩子 AVLTreeNode<T>* _Parent; // 该节点的双亲 T _val; int _bf; // 该节点的平衡因子 AVLTreeNode(const T& _dat
【含数据库+附源码+说明文档】基于Java swing和mysql实现的银行管理系统（彩色版本）
最新发布
11-04
一、项目简介 本项目是一套基于Java swing和mysql实现的银行管理系统，主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者。 包含：项目源码、项目文档、数据库脚本等，该项目附带全部源码可作为毕设使用。 项目都经过严格调试，确保可以运行！ 该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值 二、技术实现 技术栈：Java swing，mysql 三、系统功能 用户的登录功能 用户的注册功能 用户个人业务模块： 包括：取款功能， 修改密码功能， 存款功能， 显示余额功能， 转账功能， 个人信息功能， 交易明细功能， 退出系统
计算机原理之什么是重定位
11-04
计算机原理之什么是重定位
学院就业信息网 SSM毕业设计 附带论文.zip
11-04
学院就业信息网 SSM毕业设计 附带论文 启动教程:https://www.bilibili.com/video/BV1GK1iYyE2B
【java毕业设计】基于SpringBoot的小型民营加油站管理系统源码（springboot+vue+mysql+说明文档）
11-04
项目经过测试均可完美运行！ 环境说明： 开发语言：java jdk：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse
tornado-6.4-cp38-abi3-win_amd64.whl
11-04
tornado-6.4-cp38-abi3-win_amd64.whl
深入解析AVL树插入删除与旋转操作
以下是AVL树插入和删除节点后的旋转操作的详细知识点： 1. 单旋转操作： - 单左旋转（LL旋转）：如果右子树的高度大于左子树的高度，并且右子树的右子树的高度又大于其左子树的高度，那么执行单左旋转。 - 单右...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值