АВЛ-дерево работает неправильно

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
#include <cstdio>
#include <iomanip>
#include <cstdlib>
#include <ctime>
#include <cmath>
using namespace std;
 
class Node {
private:
 
    int d;
    Node* left;
    Node* right;
    int key;
    int level;
    int height;
 
public:
 
    friend class Tree;
};
 
class Tree {
private:
 
    Node *root;
    char name;
 
public:
 
    int maxLevel;
    char *mass;
 
    Tree(char letter) {
        name = letter;
    }
 
    void printTreeNodes(Node *ptr, int level, int check) {
        int reso = 20;
        int c;
        if (ptr) {
 
            if (level > (log2(ptr->key)) && ((level - 1) <= (log2(ptr->key)))) {
                cout << '\r';
                c = (reso / pow(2, level - 1)) + ((reso * 2 / pow(2, level - 1))*(ptr->key - (pow(2, level - 1))));
                if (check) {
                    for (int i = 0; i < c; i++) {
                        cout << ' ';
                    }
                    cout << ptr->d;
                }
                else {
                    for (int i = 0; i < c - 1; i++) {
                        cout << ' ';
                    }
                    cout << char(47) << " " << char(92);
                }
 
            }
 
            printTreeNodes(ptr->right, level, check);
            printTreeNodes(ptr->left, level, check);
        }
    }
 
    void printSimpleNodes(Node *ptr) {
        if (ptr != NULL) {
            cout << ptr->d << " ";
 
            printSimpleNodes(ptr->left);
            printSimpleNodes(ptr->right);
        }
    }
 
    void addLevel(Node *t, int keynumb) {
        if (t) {
            t->level = keynumb;
 
            if (keynumb > maxLevel) {
                maxLevel = keynumb;
            }
 
            addLevel(t->left, keynumb + 1);
            addLevel(t->right, keynumb + 1);
        }
    }
 
 
public:
 
    Node *Create(Node **ptr, char val, int key) {
        (*ptr) = new Node;
 
        (*ptr)->d = val;
        (*ptr)->left = NULL;
        (*ptr)->right = NULL;
        (*ptr)->key = key;
 
        return *ptr;
    }
 
    //добавление узлов дерева
 
    Node *AddNode(Node *ptr, int val, int k) {
        if (ptr == NULL) {
            ptr = Create(&ptr, val, k);
        }
        else {
            if (val < ptr->d) {
                if (ptr->left == NULL) {
                    Create(&(ptr->left), val, k);
                }
                else {
                    AddNode(ptr->left, val, 2 * k);
                    if ((treeHeight(ptr->left)) - (treeHeight(ptr->right)) == 2) {
                        if (val < ptr->left->d) {
                            ptr = rotateR(&ptr);
                        }
                        else {
                            ptr = rotateLR(&ptr);
                        }
                    }
                }
            }
            if (val > ptr->d) {
                if (ptr->right == NULL) {
                    Create(&(ptr->right), val, k + 1);
                }
                else {
                    AddNode(ptr->right, val, 2 * (k + 1));
                    if ((treeHeight(ptr->right)) - (treeHeight(ptr->left)) == 2) {
                        if (val > ptr->right->d) {
                            ptr = rotateL(&ptr);
                        }
                        else {
                            ptr = rotateRL(&ptr);
                        }
                    }
                }
            }
        }
        ptr->height = treeMax(treeHeight(ptr->left), treeHeight(ptr->right)) + 1;
 
        return ptr;
    }
 
    //повороты
 
    Node* rotateR(Node **tree) {
        Node *x;
 
        x = (*tree)->left;
        (*tree)->left = x->right;
        x->right = (*tree);
        (*tree)->height = treeMax(treeHeight((*tree)->left), treeHeight((*tree)->right)) + 1;
        x->height = treeMax(treeHeight(x->left), x->height) + 1;
 
        return x;
    }
 
    Node* rotateL(Node **tree) {
        Node *x;
 
        x = (*tree)->right;
        (*tree)->right = x->left;
        x->left = (*tree);
        (*tree)->height = treeMax(treeHeight((*tree)->left), treeHeight((*tree)->right)) + 1;
        x->height = treeMax(x->height, treeHeight(x->right)) + 1;
 
        return x;
    }
 
    Node* rotateLR(Node **tree) {
        (*tree)->left = rotateL(&(*tree)->left);
        return (rotateR(&(*tree)));
    }
 
    Node* rotateRL(Node **tree) {
        (*tree)->right = rotateR(&(*tree)->right);
        return (rotateL(&(*tree)));
    }
 
    //тут генерируются рандомные значения для дерева
 
    void genTree() {
        int n;
        int k;
        int *mass;
 
        n = 23 + rand() % 29;
        mass = new int[n];
 
        if (n != 0) {
            for (int i = 0; i < n; i++) {
                mass[i] = rand() % 100;
            }
        }
 
        for (int i = 0; i < n; i++) {
            cout << mass[i] << ' ';
        }
 
        cout << endl << endl;
 
        Create(&root, mass[0], 1);
 
        for (int i = 1; i < n; i++) {
            k = 2;
            AddNode(root, mass[i], k);
        }
    }
 
    void printTree() {
        int level = 1;
 
        cout << endl << endl;
 
        cout << "Tree " << name << ":" << endl << endl;
 
        for (int i = 1; i < maxLevel; i++) {
            printTreeNodes(root, i, 1);
            cout << endl;
            printTreeNodes(root, i, 0);
            cout << endl;
        }
 
        cout << endl;
    }
 
    int treeHeight(Node *tree) {
        if (tree == NULL) {
            return -1;
        }
        else {
            return tree->height;
        }
    }
 
    int treeMax(int h1, int h2) {
        if (h1 > h2) {
            return h1;
        }
        else {
            return h2;
        }
    }
 
    void addLevels() {
        maxLevel = 0;
        addLevel(root, 1);
    }
 
    void printSimple() {
        printSimpleNodes(root);
    }
 
    ~Tree() {
        delete[]mass;
    }
 
};
 
 
int main() {
    srand(time(0));
 
    Tree A('A');//, B('B');
 
    cout << "\nTree A: ";
    A.genTree();
    //cout << "\nTree B: ";
    //B.genTree();
 
    A.addLevels();
    //B.addLevels();
    A.printTree();
    //B.printTree();
 
    A.printSimple();
 
    system("pause");
    return 0;
}