Question

Language: C++

○ For this question I task you with creating an Iterative Search function that works with the existing binary search tree of type string. This function will be inputted a variable of type string and will search for it within the existing and pre-declared binary tree.

○ The function appears just above the main, and is simply a placeholder. It can be altered as you wish.

○ Within the Main I have a simple program to prompt for a string that will then be run through the iterativeSearch function to return true or false, depending on whether or not the string was found within the binary search tree.

Below is all of the code required to answer this question and run the program! Thank you!

NOTE: It is possible that the tree may need to be changed itself, and if so, feel free to do so.

NOTE: Only the iterativeSearch function is required for this question, so feel free to only post that portion when you have answered the question.

#include

#include

using std::string;

using namespace std;

using std::ifstream;

using std::ofstream;

using std::cout;

using std::cin;

using std::endl;

class Node

{

public:

string key;

Node *left;

Node *right;

int height;

};

// A utility function to get maximum

// of two integers

int max(int a, int b);

// A utility function to get the

// height of the tree

int height(Node *N)

{

if (N == NULL)

return 0;

return N->height;

}

// A utility function to get maximum

// of two integers

int max(int a, int b)

{

return (a > b)? a : b;

}

// Helper function that allocates a

// new node with the given key and

// NULL left and right pointers.

Node* newNode(string key)

{

Node* node = new Node();

node->key = key;

node->left = NULL;

node->right = NULL;

node->height = 1; // new node is initially

// added at leaf

return(node);

}

Node *rightRotate(Node *y)

{

Node *x = y->left;

Node *T2 = x->right;

  

// Perform rotation

x->right = y;

y->left = T2;

  

// Update heights

y->height = max(height(y->left),

height(y->right)) + 1;

x->height = max(height(x->left),

height(x->right)) + 1;

  

// Return new root

return x;

}

// A utility function to left

// rotate subtree rooted with x

// See the diagram given above.

Node *leftRotate(Node *x)

{

Node *y = x->right;

Node *T2 = y->left;

  

// Perform rotation

y->left = x;

x->right = T2;

  

// Update heights

x->height = max(height(x->left),

height(x->right)) + 1;

y->height = max(height(y->left),

height(y->right)) + 1;

  

// Return new root

return y;

}

// Get Balance factor of node N

int getBalance(Node *N)

{

if (N == NULL)

return 0;

return height(N->left) - height(N->right);

}

// Recursive function to insert a key

// in the subtree rooted with node and

// returns the new root of the subtree.

Node* insert(Node* node, string key)

{

// 1. Perform the normal BST insertion

if (node == NULL)

return(newNode(key));

  

if (key < node->key)

node->left = insert(node->left, key);

else if (key > node->key)

node->right = insert(node->right, key);

else // Equal keys are not allowed in BST

return node;

  

// 2. Update height of this ancestor node

node->height = 1 + max(height(node->left),

height(node->right));

  

// 3. Get the balance factor of this ancestor

//node to check whether this node became

//unbalanced

int balance = getBalance(node);

  

// If this node becomes unbalanced, then

// there are 4 cases

  

// Left Left Case

if (balance > 1 && key < node->left->key)

return rightRotate(node);

  

// Right Right Case

if (balance < -1 && key > node->right->key)

return leftRotate(node);

// Left Right Case

if (balance > 1 && key > node->left->key)

{

node->left = leftRotate(node->left);

return rightRotate(node);

}  

// Right Left Case

if (balance < -1 && key < node->right->key)

{

node->right = rightRotate(node->right);

return leftRotate(node);

}

// return the (unchanged) node pointer

return node;

}

bool iterativeSearch(struct Node* root, string word)

{

//CODE NEEDED HERE TO FILL THIS FUNCTION

return false;

}

int main()

{

Node *root = NULL;

     

root = insert(root, "as");

root = insert(root, "app");

root = insert(root, "aaron");

root = insert(root, "bitcoin");

root = insert(root, "bacon");

root = insert(root, "carriage");

  

cout << "Enter a search term: ";

string searchTerm;

cin >> searchTerm;  

if(iterativeSearch(root,searchTerm))

{

cout << "\n'" << searchTerm << "'" << " was found within the Binary Search Tree.\n" << endl;

}

else

{

cout << "\n'" << searchTerm << "'" << " was NOT found within the Binary Search Tree.\n" << endl;

}

return 0;

}

Answer 1

#include <iostream>

using std::string;

using namespace std;

using std::ifstream;

using std::ofstream;

using std::cout;

using std::cin;

using std::endl;

class Node

{

public:

string key;

Node *left;

Node *right;

int height;

};

// A utility function to get maximum

// of two integers

int max(int a, int b);

// A utility function to get the

// height of the tree

int height(Node *N)

{

if (N == NULL)

return 0;

return N->height;

}

// A utility function to get maximum

// of two integers

int max(int a, int b)

{

return (a > b)? a : b;

}

// Helper function that allocates a

// new node with the given key and

// NULL left and right pointers.

Node* newNode(string key)

{

Node* node = new Node();

node->key = key;

node->left = NULL;

node->right = NULL;

node->height = 1; // new node is initially

// added at leaf

return(node);

}

Node *rightRotate(Node *y)

{

Node *x = y->left;

Node *T2 = x->right;

// Perform rotation

x->right = y;

y->left = T2;

// Update heights

y->height = max(height(y->left),

height(y->right)) + 1;

x->height = max(height(x->left),

height(x->right)) + 1;

// Return new root

return x;

}

// A utility function to left

// rotate subtree rooted with x

// See the diagram given above.

Node *leftRotate(Node *x)

{

Node *y = x->right;

Node *T2 = y->left;

// Perform rotation

y->left = x;

x->right = T2;

// Update heights

x->height = max(height(x->left),

height(x->right)) + 1;

y->height = max(height(y->left),

height(y->right)) + 1;

// Return new root

return y;

}

// Get Balance factor of node N

int getBalance(Node *N)

{

if (N == NULL)

return 0;

return height(N->left) - height(N->right);

}

// Recursive function to insert a key

// in the subtree rooted with node and

// returns the new root of the subtree.

Node* insert(Node* node, string key)

{

// 1. Perform the normal BST insertion

if (node == NULL)

return(newNode(key));

if (key < node->key)

node->left = insert(node->left, key);

else if (key > node->key)

node->right = insert(node->right, key);

else // Equal keys are not allowed in BST

return node;

// 2. Update height of this ancestor node

node->height = 1 + max(height(node->left),

height(node->right));

// 3. Get the balance factor of this ancestor

//node to check whether this node became

//unbalanced

int balance = getBalance(node);

// If this node becomes unbalanced, then

// there are 4 cases

// Left Left Case

if (balance > 1 && key < node->left->key)

return rightRotate(node);

// Right Right Case

if (balance < -1 && key > node->right->key)

return leftRotate(node);

// Left Right Case

if (balance > 1 && key > node->left->key)

{

node->left = leftRotate(node->left);

return rightRotate(node);

}

// Right Left Case

if (balance < -1 && key < node->right->key)

{

node->right = rightRotate(node->right);

return leftRotate(node);

}

// return the (unchanged) node pointer

return node;

}

bool iterativeSearch(struct Node* root, string word)

{

while(root != NULL){

if( word.compare(root->key) > 0)

root = root->right;

else if( word.compare(root->key) < 0)

root = root->left;

else

return true;

}

return false;

}

int main()

{

Node *root = NULL;

root = insert(root, "as");

root = insert(root, "app");

root = insert(root, "aaron");

root = insert(root, "bitcoin");

root = insert(root, "bacon");

root = insert(root, "carriage");

cout << "Enter a search term: ";

string searchTerm;

cin >> searchTerm;

if(iterativeSearch(root,searchTerm))

{

cout << "\n'" << searchTerm << "'" << " was found within the Binary Search Tree.\n" << endl;

}

else

{

cout << "\n'" << searchTerm << "'" << " was NOT found within the Binary Search Tree.\n" << endl;

}

return 0;

}

======================================

SEE OUTPUT

PLEASE COMMENT if there is any concern.

==========================================