Question

Implement insert() in tree.cpp and show the results of inserting 2, 1, 4, 5, 9, 3, 6, 7, 10, 12, 11 into an empty Binary search tree.
2.Start with the tree in problem 1 and implement delete_node() and do:
2.1.delete 4, then
2.2.delete 9.
3.Start with the tree in problem 2 and implement search() and do:
3.1.Search 12
3.2.Search 4

#include <iostream>
#include <cstddef>

using std::cout;
using std::endl;

class Node {
int value;
public:
Node* left; // left child
Node* right; // right child
Node* p; // parent
Node(int data) {
value = data;
left = NULL;
right = NULL;
p = NULL;
}
~Node() {
}
int d() {
return value;
}
void print() {
std::cout << value << std::endl;
}
};

int main(int argc, const char * argv[])
{
  
}

function insert(Node *insert_node, Node *tree_root){
   //Your code here
}

function delete_node(int value, Node *tree_root){
   //Your code here
}

function search(int value, Node *tree_root){
   //Your code here
}

Answer 1

#include <iostream>

#include<cstdlib>

using namespace std;

class NODE

{

int data;

NODE *left, *right;

public:

// Default constructor.

NODE();

// Parameterized constructor.

NODE(int);

// Insert function.

NODE* Insert(NODE *, int);

NODE* Search(NODE *, int);

NODE* Delete(NODE *, int);

NODE* minValueNode(NODE *);

void Inorder(NODE *);

};

// Default Constructor definition.

NODE :: NODE() : data(0), left(NULL), right(NULL){}

// Parameterized Constructor definition.

NODE :: NODE(int value)

{

data = value;

left = right = NULL;

}

// Insert function definition.

NODE* NODE :: Insert(NODE *root, int value)

{

if(!root)

{

// Insert the first node, if root is NULL.

return new NODE(value);

}

// Insert data.

if(value > root->data)

{

// Insert right node data, if the 'value'

// to be inserted is greater than 'root' node data.

// Process right nodes.

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

}

else

{

// Insert left node data, if the 'value'

// to be inserted is greater than 'root' node data.

// Process left nodes.

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

}

// Return 'root' node, after insertion.

return root;

}

NODE* NODE :: minValueNode(NODE *node)

{

NODE *current = node;

/* loop down to find the leftmost leaf */

while (current && current->left != NULL)

current = current->left;

return current;

}

NODE* NODE :: Delete(NODE *root, int key)

{

// base case

if (root == NULL) return root;

// If the key to be deleted is smaller than the root's key,

// then it lies in left subtree

if (key < root->data)

root->left = Delete(root->left, key);

// If the key to be deleted is greater than the root's key,

// then it lies in right subtree

else if (key > root->data)

root->right = Delete(root->right, key);

// if key is same as root's key, then This is the node

// to be deleted

else

{

// node with only one child or no child

if (root->left == NULL)

{

NODE *temp = root->right;

free(root);

return temp;

}

else if (root->right == NULL)

{

NODE *temp = root->left;

free(root);

return temp;

}

// node with two children: Get the inorder successor (smallest

// in the right subtree)

NODE *temp = minValueNode(root->right);

// Copy the inorder successor's content to this node

root->data = temp->data;

// Delete the inorder successor

root->right = Delete(root->right, temp->data);

}

return root;

}

void NODE :: Inorder(NODE *root)

{

if(!root)

{

return;

}

Inorder(root->left);

cout << root->data << endl;

Inorder(root->right);

}

NODE* NODE :: Search(NODE *root, int value)

{

// Base Cases: root is null or value is present at root

if (root == NULL || root->data == value)

return root;

// value is greater than root's value

if (root->data < value)

return Search(root->right, value);

// value is smaller than root's value

return Search(root->left, value);

}

// Driver code

int main()

{

NODE b, *root = NULL;

root = b.Insert(root, 2);

b.Insert(root, 4);

b.Inorder(root);

b.Insert(root, 5);

b.Inorder(root);

b.Insert(root, 9);

b.Inorder(root);

b.Insert(root, 3);

b.Inorder(root);

b.Insert(root, 6);

b.Inorder(root);

b.Insert(root, 7);

b.Inorder(root);

b.Insert(root, 10);

b.Inorder(root);

b.Insert(root, 12);

b.Inorder(root);

b.Insert(root, 11);

b.Inorder(root);

b.Delete(root, 4);

b.Inorder(root);

b.Delete(root, 9);

b.Inorder(root);

b.Search(root, 12);

b.Search(root, 4);

return 0;

}