TASK 2:

#include<iostream>
#include<iomanip>
using namespace std;

class Node {
public:
string data;
Node* left;
Node* right;
};

class BinaryTree {
private:
Node* root;
public:
BinaryTree() {
root = NULL;
}

Node* getRoot() {
return root;
}

void setRoot(Node* node) {

root = node;
}

Node* CreateNode(string data) {

Node* newNode = new Node();
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}

void insert(string data) {

if (root == NULL) {
root = CreateNode(data);
}
else {
insertNode(root, data);
}
}

void insertNode(Node* node, string data) {

if (node->left == NULL) {
node->left = CreateNode(data);
}
else if (node->right == NULL) {
node->right = CreateNode(data);
}
else {

insertNode(node->left, data);
}
}
 void printTree(Node* node, int space = 0, int tcount = 10) {
if (node == NULL) {
return;
}

space += tcount;

printTree(node->right, space);

cout << endl;

for (int i = tcount; i < space; i++) {
cout << " ";
}
cout << node->data << "\n";

printTree(node->left, space);
}

};

int main() {
BinaryTree bt;
bt.insert("Depts");
bt.insert("CS");
bt.insert("SE");
bt.insert("AI");
bt.insert("CS");
bt.insert("SE");
bt.insert("BS");
bt.insert("MS");
bt.insert("BS");
bt.insert("MS");

bt.printTree(bt.getRoot());

return 0;
}
TASK 3-A:
#include<iostream>
using namespace std;

class Node
{
public:
int data;
Node* left;
Node* right;
};

class BinaryTree
{
private:
Node* root;
public:
BinaryTree()
{
root = NULL;
}

Node* getRoot() {
 return root;
}

void setRoot(Node* node) {

root = node;
}

void in_tree(int num)

{
root = InsertNode(root, num);
}

Node* CreateNode(int data)

{
Node* newNode = new Node();
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}

Node* InsertNode(Node* root, int data)

{
if (root == NULL)
{
root = CreateNode(data);
return root;
}
if (data < root->data)
{
root->left = InsertNode(root->left, data);
}
else
{
root->right = InsertNode(root->right, data);
}
return root;
}

bool isFullBinaryTree(Node* node)

{
if (node == NULL)
{
return true;
}
if (node->left == NULL && node->right == NULL)
{
return true;
}
if ((node->left) && (node->right))
{
return (isFullBinaryTree(node->left) && isFullBinaryTree(node->right));
}
return false;
}
};

int main() {
BinaryTree bt;
 bt.in_tree(12);
bt.in_tree(18);
bt.in_tree(8);
bt.in_tree(5);
bt.in_tree(11);

if (bt.isFullBinaryTree(bt.getRoot()))
cout << "The tree is a full binary tree\n";
else
cout << "The tree is not a full binary tree\n";

return 0;
}

TASK 3-B:
#include <iostream>
using namespace std;

class Node {
public:
int data;
Node* left;
Node* right;
};

class BinaryTree {
private:
Node* root;

public:
BinaryTree() {
root = NULL;
}
 Node* getRoot() {
return root;
}

void setRoot(Node* node) {

root = node;
}

Node* CreateNode(int data) {

Node* newNode = new Node();
if (!newNode) {
cout << "Memory error\n";
return NULL;
}
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}

Node* InsertNode(Node* root, int data) {

if (root == NULL) {
root = CreateNode(data);
return root;
}

if (data < root->data)

root->left = InsertNode(root->left, data);
else
root->right = InsertNode(root->right, data);

return root;
}

int sumOfLeftNodes(Node* node) {

if (node == NULL)
return 0;
else
return node->data + sumOfLeftNodes(node->left) + sumOfLeftNodes(node->right);
}

int sumOfRightNodes(Node* node) {

if (node == NULL)
return 0;
else
return node->data + sumOfRightNodes(node->left) + sumOfRightNodes(node->right);
}
};

int main() {
BinaryTree bt;

bt.setRoot(bt.InsertNode(bt.getRoot(), 3722));

bt.InsertNode(bt.getRoot(), 85);
bt.InsertNode(bt.getRoot()->left, 78);
bt.InsertNode(bt.getRoot()->left, 76);
 bt.InsertNode(bt.getRoot(), 0);
bt.InsertNode(bt.getRoot()->right, 0);
bt.InsertNode(bt.getRoot()->right, 0);

int sumLeft = bt.sumOfLeftNodes(bt.getRoot()->left);

int sumRight = bt.sumOfRightNodes(bt.getRoot()->right);

cout << "Sum of left nodes: " << sumLeft << endl;
cout << "Sum of right nodes: " << sumRight << endl;

return 0;
}

TASK 4:
#include<iostream>
using namespace std;

struct Node {
int data;
Node* left;
Node* right;
};

class BinaryTree {
private:
Node* root;
public:
BinaryTree() {
root = NULL;
}

Node* getRoot() {
return root;
}

void setRoot(Node* node) {

root = node;
}

void in_tree(int num)

 {
root = InsertNode(root, num);
}

Node* CreateNode(int data) {

Node* newNode = new Node();
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}

Node* InsertNode(Node* root, int data) {

if (root == NULL) {
root = CreateNode(data);
return root;
}

if (data < root->data)

root->left = InsertNode(root->left, data);
else
root->right = InsertNode(root->right, data);

return root;
}

int countNodesGivenLevel(Node* node, int level) {

if (node == NULL)
return 0;
if (level == 1)
return 1;
else
return countNodesGivenLevel(node->left, level - 1) + countNodesGivenLevel(node->right,
level - 1);
}

void freeTree(Node* node) {

if (node == NULL)
return;

freeTree(node->left);
freeTree(node->right);

delete node;
}

int height(Node* node) {

if (node == NULL)
return 0;
else {
int lheight = height(node->left);
int rheight = height(node->right);

if (lheight > rheight)

return(lheight + 1);
else return(rheight + 1);
}
}
 void printGivenLevel(Node* root, int level) {
if (root == NULL)
return;
if (level == 1)
cout << root->data << " ";
else if (level > 1) {
printGivenLevel(root->left, level - 1);
printGivenLevel(root->right, level - 1);
}
}

void printLevelOrder(Node* root) {

int h = height(root);
for (int i = 1; i <= h; i++)
printGivenLevel(root, i);
}
};

int main() {
BinaryTree bt;
bt.in_tree(85);
bt.in_tree(90);
bt.in_tree(78);
bt.in_tree(92);
bt.in_tree(88);
bt.in_tree(76);
bt.in_tree(95);
bt.in_tree(89);
bt.in_tree(91);
bt.in_tree(87);

cout << "Number of nodes at level 3: " << bt.countNodesGivenLevel(bt.getRoot(), 3) << "\n";

cout << "Height of tree: " << bt.height(bt.getRoot()) << "\n";

cout << "Level order traversal: ";

bt.printLevelOrder(bt.getRoot());

bt.freeTree(bt.getRoot());

return 0;
}
TASK 5:
#include <iostream>
#include <iomanip>
using namespace std;

class Node {
public:
int data;
Node* left;
Node* right;
};

class BinaryTree {
private:
Node* root;
public:
BinaryTree() {
root = NULL;
}

Node* getRoot() {
return root;
}

void setRoot(Node* node) {

root = node;
}

void in_tree(int data)

{
root = InsertNode(root, data);
}

Node* CreateNode(int data) {

Node* newNode = new Node();
if (!newNode) {
cout << "Memory error\n";
return NULL;
}
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}

Node* InsertNode(Node* root, int data) {

if (root == NULL) {
root = CreateNode(data);
return root;
}

if (data < root->data)

root->left = InsertNode(root->left, data);
else
root->right = InsertNode(root->right, data);

return root;
 }
void printTree(Node* node, int space = 0, int tcount = 10) {
if (node == NULL) {
return;
}

space += tcount;

printTree(node->right, space);

cout << endl;

for (int i = tcount; i < space; i++) {
cout << " ";
}
cout << node->data << "\n";

printTree(node->left, space);
}

void printInorder(Node* node) {

if (node == NULL)
return;

printInorder(node->left);
cout << node->data << ' ';
printInorder(node->right);
}

void printPostorder(Node* node) {

if (node == NULL)
return;

printPostorder(node->left);
printPostorder(node->right);
cout << node->data << ' ';
}

void printPreorder(Node* node) {

if (node == NULL)
return;

cout << node->data << ' ';

printPreorder(node->left);
printPreorder(node->right);
}
};

int main() {
BinaryTree bt;
bt.in_tree(12);
bt.in_tree(18);
bt.in_tree(8);
bt.in_tree(5);
bt.in_tree(36);
bt.in_tree(25);
bt.in_tree(911);
bt.in_tree(3);
bt.in_tree(9);
 bt.in_tree(2);

cout << "Binary Tree: " << endl;

bt.printTree(bt.getRoot());

cout << "\nInorder traversal: ";

bt.printInorder(bt.getRoot());

cout << "\nPostorder traversal: ";

bt.printPostorder(bt.getRoot());

cout << "\nPreorder traversal: ";

bt.printPreorder(bt.getRoot());

return 0;
}