#include <iostream>

#include <algorithm>

struct Node {

int data;

Node* left;

Node* right;

int height;

Node(int value) {

data = value;

left = nullptr;

right = nullptr;

height = 1;

};

// Funcție pentru obținerea înălțimii unui nod

int getHeight(Node* node) {

if (node == nullptr) {

return 0;

return node->height;

// Funcție pentru calcularea factorului de echilibru al unui nod

int getBalanceFactor(Node* node) {

if (node == nullptr) {

return 0;

return getHeight(node->left) - getHeight(node->right);

}
// Funcție pentru actualizarea înălțimii unui nod

void updateHeight(Node* node) {

if (node == nullptr) {

return;

node->height = 1 + std::max(getHeight(node->left), getHeight(node->right));

// Funcție pentru rotirea la stânga a unui subarbore

Node* rotateLeft(Node* root) {

Node* newRoot = root->right;

Node* subtree = newRoot->left;

newRoot->left = root;

root->right = subtree;

updateHeight(root);

updateHeight(newRoot);

return newRoot;

// Funcție pentru rotirea la dreapta a unui subarbore

Node* rotateRight(Node* root) {

Node* newRoot = root->left;

Node* subtree = newRoot->right;

newRoot->right = root;

root->left = subtree;

updateHeight(root);
 updateHeight(newRoot);

return newRoot;

// Funcție pentru inserarea unui nod în arborele AVL

Node* insert(Node* root, int value) {

if (root == nullptr) {

return new Node(value);

if (value < root->data) {

root->left = insert(root->left, value);

} else {

root->right = insert(root->right, value);

updateHeight(root);

int balanceFactor = getBalanceFactor(root);

// Cazul 1: Nodul este dezechilibrat spre stânga și subarborele stâng este mai înalt

if (balanceFactor > 1 && value < root->left->data) {

return rotateRight(root);

// Cazul 2: Nodul este dezechilibrat spre dreapta și subarborele drept este mai înalt

if (balanceFactor < -1 && value > root->right->data) {

return rotateLeft(root);

// Cazul 3: Nodul este dezechilibrat spre stânga și subarborele stâng este mai scurt
 if (balanceFactor > 1 && value > root->left->data) {

root->left = rotateLeft(root->left);

return rotateRight(root);

// Cazul 4: Nodul este dezechilibrat spre dreapta și subarborele drept este mai scurt

if (balanceFactor < -1 && value < root->right->data) {

root->right = rotateRight(root->right);

return rotateLeft(root);

return root;

// Parcurgere în ordine (left -> root -> right)

void inorderTraversal(Node* root) {

if (root == nullptr) {

return;

inorderTraversal(root->left);

std::cout << root->data << " ";

inorderTraversal(root->right);

// Parcurgere în preordine (root -> left -> right)

void preorderTraversal(Node* root) {

if (root == nullptr) {

return;

std::cout << root->data << " ";

 preorderTraversal(root->left);

preorderTraversal(root->right);

// Parcurgere în postordine (left -> right -> root)

void postorderTraversal(Node* root) {

if (root == nullptr) {

return;

postorderTraversal(root->left);

postorderTraversal(root->right);

std::cout << root->data << " ";

int main() {

Node* root = nullptr;

// Citirea elementelor de la tastatură și inserarea lor în arbore

int element;

while (std::cin >> element) {

root = insert(root, element);

std::cout << "Parcurgere in ordine: ";

inorderTraversal(root);

std::cout << std::endl;

std::cout << "Parcurgere in preordine: ";

preorderTraversal(root);

std::cout << std::endl;

 std::cout << "Parcurgere in postordine: ";

postorderTraversal(root);

std::cout << std::endl;

return 0;