C++ 为什么我的AVL树删除功能不平衡？_C++

C++ 为什么我的AVL树删除功能不平衡？

c++

C++ 为什么我的AVL树删除功能不平衡？,c++,C++,我的删除功能无法正常工作。删除节点时，不会重新平衡整个树。有时它平衡左子树，但忽略整个右子树。代码相当长 class AVLTree { public: void insert(const DataType &item); void graph(ostream &out) const; void remove(DataType &value); private: class AVLNode { public:

我的删除功能无法正常工作。删除节点时，不会重新平衡整个树。有时它平衡左子树，但忽略整个右子树。代码相当长

class AVLTree
{
public:
    void insert(const DataType &item);
    void graph(ostream &out) const;
    void remove(DataType &value);
private:
    class AVLNode
    {
    public:
        DataType data;
        int balanceFactor;
        AVLNode *left;
        AVLNode *right;
        AVLNode():balanceFactor(0),left(NULL),right(NULL){}
        AVLNode(DataType item):balanceFactor(0), data(item),left(NULL), right(NULL){}
    };
    typedef AVLNode* AVLNodePointer;
    AVLNodePointer myRoot;
    int height(AVLTree<DataType>::AVLNodePointer temp);
    int different(AVLTree<DataType>::AVLNodePointer temp);
    AVLNodePointer ll_rotation(AVLTree<DataType>::AVLNodePointer parent);
    AVLNodePointer rr_rotation(AVLTree<DataType>::AVLNodePointer parent);
    AVLNodePointer lr_rotation(AVLTree<DataType>::AVLNodePointer parent);
    AVLNodePointer rl_rotation(AVLTree<DataType>::AVLNodePointer parent);
    AVLNodePointer balance_tree(AVLTree<DataType>::AVLNodePointer temp);
    AVLNodePointer insertAux(AVLTree<DataType>::AVLNodePointer &subtreeRoot,const DataType &value);
    AVLNodePointer findmin(AVLTree<DataType>::AVLNodePointer temp);
    AVLNodePointer deleteAux(AVLTree<DataType>::AVLNodePointer temp,DataType &value);
    void graphAux(ostream &out,int indent,  AVLTree<DataType>::AVLNodePointer subtreePtr) const;
                            };
template<typename DataType>
int AVLTree<DataType>::height(AVLTree<DataType>::AVLNodePointer temp)
{
     int h=0;
     if(temp!=NULL)
 {
    int left_height=height(temp->left);
    int right_height=height(temp->right)
    int max_height =max(left_height,right_height);
    h=max_height +1;
 }
 return h;
}

template<typename DataType>
int AVLTree<DataType>::different(AVLTree<DataType>::AVLNodePointer temp)
{
int left_height=height(temp->left);
int right_height=height(temp->right);
temp->balanceFactor=left_height-right_height;
return temp->balanceFactor;
}

template<typename DataType>
typename AVLTree<DataType>::AVLNodePointer AVLTree<DataType>::ll_rotation(AVLTree<DataType>::AVLNodePointer parent)
{
AVLTree<DataType>::AVLNodePointer temp;
temp=parent->left;
parent->left=temp->right;
temp->right=parent;
return temp;
}

template<typename DataType>
typename AVLTree<DataType>::AVLNodePointer AVLTree<DataType>::rr_rotation(AVLTree<DataType>::AVLNodePointer parent)
{
AVLTree<DataType>::AVLNodePointer temp;
temp=parent->right;
parent->right=temp->left;
temp->left=parent;
return temp;
}

template<typename DataType>
typename AVLTree<DataType>::AVLNodePointer AVLTree<DataType>::lr_rotation(AVLTree<DataType>::AVLNodePointer parent)
{
AVLTree<DataType>::AVLNodePointer temp;
temp=parent->left;
parent->left=rr_rotation(temp);
return ll_rotation(parent);
}

template<typename DataType>
typename AVLTree<DataType>::AVLNodePointer AVLTree<DataType>::rl_rotation(AVLTree<DataType>::AVLNodePointer parent)
{
AVLTree<DataType>::AVLNodePointer temp;
temp=parent->right;
parent->right=ll_rotation(temp);
return rr_rotation(parent);
}

template<typename DataType>
typename AVLTree<DataType>::AVLNodePointer AVLTree<DataType>::balance_tree(AVLTree<DataType>::AVLNodePointer temp)
{
temp->balanceFactor=different(temp);

if(temp->balanceFactor>1)
{
    if(different(temp->left)>0)
    {
        temp=ll_rotation(temp);
    }
    else
    {
        temp=lr_rotation(temp);
    }
}
else if(temp->balanceFactor<-1)
{
    if(different(temp->right)>0)
    {
        temp=rl_rotation(temp);
    }
    else
    {
        temp=rr_rotation(temp);
    }
}
return temp;  //no balance needed
}

template<typename DataType>
typename AVLTree<DataType>::AVLNodePointer AVLTree<DataType>::findmin(AVLTree<DataType>::AVLNodePointer temp)
{
    if(temp->left==NULL)
    {
        return temp;
    }
    else
    {
        findmin(temp->left);
    }
}
template<typename DataType>
void AVLTree<DataType>::remove(DataType &value)
{
    deleteAux(myRoot,value);
}

template<typename DataType>
typename AVLTree<DataType>::AVLNodePointer AVLTree<DataType>::deleteAux(AVLTree<DataType>::AVLNodePointer temp,DataType &value)
{

if(temp==NULL)
{
    return temp;
}
if (value<temp->data)
{
    temp->left=deleteAux(temp->left,value);
    temp=balance_tree(temp);
}
else if(value>temp->data)
{
    temp->right=deleteAux(temp->right,value);
    temp= balance_tree(temp);
}
else
{
    if(temp->left==NULL && temp->right==NULL)
    {
        AVLTree<DataType>::AVLNodePointer temp1;
        temp1=temp;
        delete temp1;
        temp=NULL;
    }
    else if(temp->left==NULL)
    {
        AVLTree<DataType>::AVLNodePointer temp1=temp;
        temp=temp->right;
        delete temp1;
        temp1=NULL;

    }
    else if(temp->right==NULL)
    {
        AVLTree<DataType>::AVLNodePointer temp1=temp;
        temp=temp->left;
        delete temp1;
        temp1=NULL;

    }
    else
    {
        AVLTree<DataType>::AVLNodePointer temp1=findmin(temp->right);
        temp->data=temp1->data;
        temp->right=deleteAux(temp->right, temp1->data);
    }

}
return temp;
}

class-AVLTree
{
公众：
无效插入（常量数据类型和项目）；
空隙图（ostream&out）常数；
作废删除（数据类型和值）；
私人：
类AVLNode
{
公众：
数据类型数据；
内平衡因子；
AVLNode*左；
AVLNode*右；
AVLNode（）：平衡因子（0），左（NULL），右（NULL）{}
AVLNode（数据类型项）：平衡因子（0），数据（项），左（空），右（空）{}
};
typedef AVLNode*AVLNodePointer；
AVLnode指针myRoot；
int高度（AVLTree:：AVLNodePointer temp）；
int-different（AVLTree:：AVLNodePointer-temp）；
AVLNodePointer ll_旋转（AVLTree:：AVLNodePointer父级）；
AVLNodePointer rr_旋转（AVLTree:：AVLNodePointer父级）；
AVLNodePointer lr_旋转（AVLTree:：AVLNodePointer父级）；
AVLNodePointer rl_旋转（AVLTree:：AVLNodePointer父级）；
AVLNodePointer平衡树（AVLTree:：AVLNodePointer temp）；
AVLNodePointer insertAux（AVLTree:：AVLNodePointer和subtreeRoot、const数据类型和值）；
AVLNodePointer findmin（AVLTree:：AVLNodePointer temp）；
AVLNodePointer deleteAux（AVLTree:：AVLNodePointer temp、数据类型和值）；
void graphAux（ostream&out、int缩进、AVLTree:：AVLNodePointer subtreePtr）常量；
};
模板
int-AVLTree:：height（AVLTree:：AVLNodePointer-temp）
{
int h=0；
如果（温度！=NULL）
{
int left_height=高度（温度->左侧）；
int right_height=高度（温度->右侧）
int max_height=max（左_height，右_height）；
h=最大高度+1；
}
返回h；
}
模板
int-AVLTree:：different（AVLTree:：AVLNodePointer-temp）
{
int left_height=高度（温度->左侧）；
int right_height=高度（温度->右侧）；
温度->平衡系数=左侧高度-右侧高度；
返回温度->平衡系数；
}
模板
类型名称AVLTree:：AVLNodePointer AVLTree:：ll_旋转（AVLTree:：AVLNodePointer父级）
{
AVLTree:：AVLNodePointer temp；
临时=父级->左；
父项->左=临时->右；
临时->右=父级；
返回温度；
}
模板
类型名称AVLTree:：AVLNodePointer AVLTree:：rr_旋转（AVLTree:：AVLNodePointer父级）
{
AVLTree:：AVLNodePointer temp；
临时=父级->右侧；
父级->右=临时->左；
临时->左=父级；
返回温度；
}
模板
类型名称AVLTree:：AVLNodePointer AVLTree:：lr_旋转（AVLTree:：AVLNodePointer父级）
{
AVLTree:：AVLNodePointer temp；
临时=父级->左；
父级->左=rr_旋转（温度）；
返回ll_旋转（父级）；
}
模板
类型名称AVLTree:：AVLNodePointer AVLTree:：rl_旋转（AVLTree:：AVLNodePointer父级）
{
AVLTree:：AVLNodePointer temp；
临时=父级->右侧；
父级->右侧=ll_旋转（温度）；
返回rr_旋转（父级）；
}
模板
类型名称AVLTree:：AVLNodePointer AVLTree:：balance_树（AVLTree:：AVLNodePointer temp）
{
温度->平衡系数=不同（温度）；
如果（温度->平衡系数>1）
{
如果（不同（温度->左侧）>0）
{
温度=ll_旋转（温度）；
}
其他的
{
温度=lr_旋转（温度）；
}
}
如果（温度->平衡系数右）>0，则为其他情况
{
温度=rl_旋转（温度）；
}
其他的
{
温度=rr_旋转（温度）；
}
}
返回温度//不需要平衡
}
模板
类型名AVLTree:：AVLNodePointer AVLTree:：findmin（AVLTree:：AVLNodePointer temp）
{
如果（临时->左==NULL）
{
返回温度；
}
其他的
{
findmin（临时->左）；
}
}
模板
void AVLTree:：remove（数据类型和值）
{
deleteAux（myRoot，value）；
}
模板
类型名称AVLTree:：AVLNodePointer AVLTree:：deleteAux（AVLTree:：AVLNodePointer临时、数据类型和值）
{
if（temp==NULL）
{
返回温度；
}
if（值数据）
{
临时->左=删除辅助（临时->左，值）；
温度=平衡树（温度）；
}
否则如果（值>温度->数据）
{
temp->right=deleteAux（temp->right，value）；
温度=平衡树（温度）；
}
其他的
{
如果（临时->左==NULL和临时->右==NULL）
{
AVLTree:：AVLNodePointer temp1；
temp1=temp；
删除temp1；
温度=零；
}
else if（临时->左==NULL）
{
AVLTree:：AVLNodePointer temp1=temp；
温度=温度->右侧；
删除temp1；
temp1=NULL；
}
else if（临时->右==NULL）
{
AVLTree:：AVLNodePointer temp1=temp；
温度=温度->左侧；
删除temp1；
temp1=NULL；
}
其他的
{
AVLTree:：AVLNodePointer temp1=findmin（temp->right）；
temp->data=temp1->data；
temp->right=deleteAux（temp->right，temp1->data）；
}
}
返回温度；
}

只需编辑忘记添加删除功能

您应该尝试使用调试器对代码进行调试，以查看发生了什么

跳出的一点是，您在第一次调用中没有使用

deleteAux

中的返回值，因此如果deleteAux更改了根应该是什么，您就没有正确的根值。尝试将

remove

功能更改为：

myRoot = deleteAux(myRoot,value);