Data structures 正在尝试插入Avl树

我正在尝试为Avl树创建一个插入方法，但是节点的结构和顺序被证明是不正确的。我很难找到哪里出了问题

以下是我的方法 任何形式的帮助都将不胜感激

模板

void AvL<T>::insert(string val, T k)
{
    if (head == NULL) {
    head = new AvLNode<T>(val, k);
} else {
    put(head, val, k);
}

void AvL:：insert（字符串val，tk）
{
if（head==NULL）{
head=新的AvLNode（val，k）；
}否则{
put（头，瓦尔，k）；
}

}

模板
void AvL:：put（AvLNode*root，string val，T key1）{
如果（根->键>键1）{
如果（根->左！=NULL）{
放置（根->左，val，键1）；
平衡（根，键1）；
}否则{
根->左=新的AvLNode（val，键1）；
根->bf=节点高度（根->左）-节点高度（根->右）；
根->左->父=根；
}
}否则{
如果（根->右！=NULL）{
放置（根->右，val，键1）；
平衡（根，键1）；
}否则{
根->右=新的AvLNode（val，键1）；
根->bf=节点高度（根->左）-节点高度（根->右）；
根->右->父=根；
}
}
}
样板
void AvL:：Balance（AvLNode*root，T键1）
{root->bf=nodeHeight（root->left）-nodeHeight（root->right）；
if（root->bf<-1&&key1>root->right->key）{
cout bf>1&&key1left->key）{
cout bf<-1&&key1right->key）{
右旋转（根->右）；
cout bf>1&&key1>root->left->key）{
左旋转（根->左）；
不能离开；
节点->左=节点1->右；
node1->right=节点；
节点->bf=节点高度（节点->左）-节点高度（节点->右）；
节点1->bf=节点高度（节点1->左）-节点高度（节点1->右）；
node=node1；
}
样板
void AvL:：LeftRotate（AvLNode*节点）
{
AvLNode*node1=节点->右侧；
节点->右侧=节点1->左侧；
节点1->左=节点；
节点->bf=节点高度（节点->左）-节点高度（节点->右）；
节点1->bf=节点高度（节点1->左）-节点高度（节点1->右）；
node=node1；
}
样板
intavl:：节点高度（AvLNode*n）
{
int lheight=0；
int-rheight=0；
int h=0；
如果（n==NULL）
{
返回-1；
}否则{
lheight=节点height（n->left）；
rheight=节点高度（n->右侧）；
h=1+最大值（左侧、右侧）；
返回h；
}
}

我的.h文件

template <class T> 
struct AvLNode
{
string value;
T key;
AvLNode *parent; // pointer to parent node
AvLNode *left; // pointer to left child
AvLNode *right; // pointer to right child
int bf; // Balance factor of node


AvLNode(string Val, T k)
{
    this->value = Val;
    this->key = k;
    this->parent = NULL;
    this->left = NULL;
    this->right = NULL;
    bf = 0;
}
};
template <class T>
class AvL
{
AvLNode<T> *head;

public:
// Constructor
AvL();

// Destructor
~AvL();

// Insertion Function
void insert(string val, T k); // inserts the given key value pair into the tree
void Balance(AvLNode<T>* node, T key1);
void delete_node(T k); // deletes the node for the given key
void RightRotate(AvLNode<T>* node);
void LeftRotate(AvLNode<T>* node);
void put(AvLNode<T>* root,string val,T key1);
int nodeHeight(AvLNode<T> *n); // returns height of the subtree from given node
};

模板
结构AvLNode
{
字符串值；
T键；
AvLNode*parent；//指向父节点的指针
AvLNode*left；//指向左子级的指针
AvLNode*right；//指向右子级的指针
int bf；//节点的平衡因子
AvLNode（字符串值，tK）
{
该->值=Val；
该->键=k；
此->父项=空；
此->左=空；
此->右=空；
bf=0；
}
};
样板
类AvL
{
AvLNode*头；
公众：
//建造师
AvL（）；
//析构函数
~AvL（）；
//插入函数
void insert（string val，T k）；//将给定的键值对插入到树中
无效余额（AvLNode*节点，T键1）；
void delete_node（tk）；//删除给定密钥的节点
void RightRotate（AvLNode*节点）；
void LeftRotate（AvLNode*节点）；
void put（AvLNode*root，字符串val，T键1）；
int nodeHeight（AvLNode*n）；//返回给定节点的子树高度
};

您的平衡函数是错误的。由于您已经将新节点插入到树中，您不必再担心

平衡（）中的键了。

-因此原型应该如下所示：

模板
void AvL:：Balance（AvLNode*root）；

您现在的做法似乎是尝试根据刚才插入的键进行平衡-这是不必要的！您可以根据节点的平衡因子来平衡树-下面是如何实现的

template<class T>
void AvL<T>::Balance(AvLNode<T>* root) {
    if (root->bf > 1) {
        if (root->left->bf == -1) LeftRotate(root->left);
        RightRotate(root);
    } else if (root->bf < -1) {
        if (root->right->bf == 1) RightRotate(root->right);
        LeftRotate(root);
    }
}

模板
void AvL:：余额（AvLNode*root）{
如果（根->bf>1）{
如果（根->左->bf==-1）左旋转（根->左）；
右旋转（根）；
}否则如果（根->bf<-1）{
如果（根->右->bf==1）向右旋转（根->右）；
左旋转（根）；
}
}

---

你可以阅读更多关于它的内容，但你的想法似乎已经不那么清晰了。你需要在概念上改变的唯一一件事是，你正在根据刚刚插入的键进行平衡。你不是——你是在根据树的形状进行平衡，你可以从每个子树的平衡因子中获得平衡。

我插入了这个函数In我的代码要测试，但即使使用此函数，我的树的结构仍然不正确。我通过查看树的形状来了解平衡方面的情况，因为在我使用我的平衡（）中的键之前我试着只使用根函数，但它不起作用，因此我求助于使用键方法。我的rightrotate或leftrotate函数可能有问题吗？啊，事实上，我想是的。我不是100%确定-但在你的

rotate（）的最后一行

函数，您可以这样做：

node=node1；

。您试图做的是使

node1

成为平衡树的新根-但该行不起作用。它所做的只是重新分配局部变量

node

-在函数之外没有任何效果。请尝试更改

void RightRotate（AvLNode*node）；

到

AvLNode RightRotate（AvLNode*node）；

，和

node=node1；

到

返回node1

，以及所有

rotateRight（root）

调用

root=rotateRight（root）

-因此您更改了实际的根节点。即使这样也不能解决问题。我无法知道哪里出了问题。当我的程序进入平衡函数时，它不会在任何if条件下运行。

template<class T>
void AvL<T>::Balance(AvLNode<T>* root) {
    if (root->bf > 1) {
        if (root->left->bf == -1) LeftRotate(root->left);
        RightRotate(root);
    } else if (root->bf < -1) {
        if (root->right->bf == 1) RightRotate(root->right);
        LeftRotate(root);
    }
}