The document outlines the implementation requirements for various AVL tree rotation and traversal methods in C++. It specifies coding tasks including the rotate left, rotate right, rotate left-right, and rotate right-left methods, as well as implementing a rebalance method and traversal techniques. Additionally, it emphasizes that the implementation should adhere to the existing function signatures without any alterations.

1. b. (10 pts) Implement the rotate left method for AVL trees.
c. (10 pts) Implement the rotate right method for AVL trees.
d. (10 pts) Implement the rotate left-right method for AVL trees.
e. (10 pts) Implement the rotate right-left method for AVL trees.
f. (15 pts) Implement the rebalance method for AVL trees.
g. (3 pts) Implement pre-order, in-order, and post-order traversals for AVL trees.
All of this should be implemented in the below code, in C++, without changing any of the
parameters or functions as they are laid out.
#include
#include
#include "AVLTree.h"
#include "AVLNode.h"
using namespace std;
AVLTree::AVLTree() {
root = nullptr;
size = 0;
}
std::shared_ptr AVLTree::getRoot() {
return root;
}
int AVLTree::getSize() {
return size;
}
std::shared_ptr AVLTree::search(int val) {
return search(root, val);
}
std::shared_ptr AVLTree::search(std::shared_ptr n, int val) {
if (n == NULL) //if root node is null just return null value
{
return n;
}
//if target is less than root's value search in left half
if (val < n->value)
{

2. return search(n->left, val);
}
//if target is greater than root's value search in right half
else if (val > n->value)
{
return search(n->right, val);
}
//else if target is equal to root node just return the root node i.e n.
return n;
}
std::shared_ptr AVLTree::minimum() {
std::shared_ptr curr = root;
while (curr && curr->left) {
curr = curr->left;
}
return curr;
}
std::shared_ptr AVLTree::minimum(std::shared_ptr n) {
std::shared_ptr curr = n;
while (curr && curr->left) {
curr = curr->left;
}
return curr;
}
std::shared_ptr AVLTree::maximum() {
std::shared_ptr curr = root;
while (curr && curr->right) {
curr = curr->right;
}
return curr;
}
std::shared_ptr AVLTree::maximum(std::shared_ptr n) {
std::shared_ptr curr = n;
while (curr && curr->right) {
curr = curr->right;
}

3. return curr;
}
int getHeight(std::shared_ptr n) {
if (n == nullptr) {
return -1;
}
return n->height;
}
int getBalanceFactor(std::shared_ptr n) {
if (n == nullptr) {
return 0;
}
return getHeight(n->left) - getHeight(n->right);
}
void AVLTree::insertValue(int val) {
root = insertValue(root, val);
}
std::shared_ptr AVLTree::insertValue(std::shared_ptr n, int val) {
if (n == nullptr) {
shared_ptr newNode(new AVLNode(val));
size++;
return newNode;
}
if (val < n->value) {
n->left = insertValue(n->left, val);
}
else if (val > n->value) {
n->right = insertValue(n->right, val);
}
else {
// Duplicate value, no change
return n;
}
// Update the height of the current node
n->height = 1 + max(getHeight(n->left), getHeight(n->right));
// Rebalance the node if necessary

4. return rebalance(n);
}
void AVLTree::deleteValue(int val) {
root = deleteValue(root, val);
}
std::shared_ptr AVLTree::deleteValue(std::shared_ptr n, int val) {
if (n == nullptr) {
return nullptr;
}
if (val < n->value) {
n->left = deleteValue(n->left, val);
}
else if (val > n->value) {
n->right = deleteValue(n->right, val);
}
else {
// Found the value to delete
if (n->left == nullptr && n->right == nullptr) {
// Leaf node, just delete it
n = nullptr;
size--;
}
else if (val > n->value)
{
n->right = deleteValue(n->right, val);
}
else // if val == n->value, then we have found the node to delete
{
if (n->left == nullptr || n->right == nullptr) // if node has only one child or no child
{
std::shared_ptr temp;
if (n->left != nullptr)
temp = n->left;
else
temp = n->right;

5. if (temp == nullptr) // no child case
{
temp = n;
n = nullptr;
}
else // one child case
{
*n = *temp;
}
}
else // node has two children
{
// get the inorder successor
std::shared_ptr temp = minimum(n->right);
// copy the inorder successor's value to this node
n->value = temp->value;
// delete the inorder successor
n->right = deleteValue(n->right, temp->value);
}
}
if (n == nullptr)
return n;
// update height of the current node
n->height = std::max(getHeight(n->left), getHeight(n->right)) + 1;
// check balance factor of the current node
int balance = getBalanceFactor(n);
// if the node becomes unbalanced, there are four possible cases:
// left left case
if (balance > 1 && getBalanceFactor(n->left) >= 0)
return rotateRight(n);
// left right case
if (balance > 1 && getBalanceFactor(n->left) < 0)
{
n->left = rotateLeft(n->left);
return rotateRight(n);
}

6. // right right case
if (balance < -1 && getBalanceFactor(n->right) <= 0)
return rotateLeft(n);
// right left case
if (balance < -1 && getBalanceFactor(n->right) > 0)
{
n->right = rotateRight(n->right);
return rotateLeft(n);
}
return n;
}
}
std::shared_ptr AVLTree::rebalance(std::shared_ptr n) {
return nullptr;
}
std::shared_ptr AVLTree::rotateLeft(std::shared_ptr n)
{
return null_ptr;
}
std::shared_ptr AVLTree::rotateRight(std::shared_ptr n) {
return nullptr;
}
std::shared_ptr AVLTree::rotateLeftRight(std::shared_ptr n)
{
return null_ptr;
}
std::shared_ptr AVLTree::rotateRightLeft(std::shared_ptr n)
{
return null_ptr;
}
void AVLTree::preOrder(std::shared_ptr n, vector>& order) {
return nullptr;
}
void AVLTree::inOrder(std::shared_ptr n, vector>& order) {
return nullptr;

7. }
void AVLTree::postOrder(std::shared_ptr n, vector>& order) {
return nullptr;
}
Below are files that are just reference code. Do not change the below code.
AVLNode.cpp:
#include "AVLNode.h"
AVLNode::AVLNode(){
value = 0;
height = 0;
balanceFactor = 0;
left = nullptr;
right = nullptr;
parent = nullptr;
}
AVLNode::AVLNode(int v){
value = v;
height = 0;
balanceFactor = 0;
left = nullptr;
right = nullptr;
parent = nullptr;
}
AVLNode.h:
#ifndef AVLNODE_H
#define AVLNODE_H
#include
class AVLNode{
public:
int value;
int height;
int balanceFactor;
std::shared_ptr left;
std::shared_ptr right;
std::shared_ptr parent; // you are not required to update parent nodes but you may use them if

8. you want
AVLNode();
AVLNode(int);
};
#endif
AVLTree.h:
#ifndef AVLTREE_H
#define AVLTREE_H
#include
#include
#include "AVLNode.h"
class AVLTree{
public:
AVLTree();
std::shared_ptr getRoot();
int getSize();
std::shared_ptr search(int);
std::shared_ptr minimum();
std::shared_ptr maximum();
void insertValue(int);
void deleteValue(int);
void preOrder(std::shared_ptr, std::vector>&);
void inOrder(std::shared_ptr, std::vector>&);
void postOrder(std::shared_ptr, std::vector>&);
private:
std::shared_ptr root;
int size;
std::shared_ptr search(std::shared_ptr, int);
std::shared_ptr minimum(std::shared_ptr);
std::shared_ptr maximum(std::shared_ptr);
std::shared_ptr insertValue(std::shared_ptr, int);
std::shared_ptr deleteValue(std::shared_ptr, int);
std::shared_ptr rebalance(std::shared_ptr);
std::shared_ptr rotateLeft(std::shared_ptr);

9. std::shared_ptr rotateRight(std::shared_ptr);
std::shared_ptr rotateLeftRight(std::shared_ptr);
std::shared_ptr rotateRightLeft(std::shared_ptr);
};
#endif