Write a function int levelSearch(Node* root, int key) that takes as input the root node of a Binary Search tree and a key. The function searches the key in the BST and returns the level of the found node. If the key is not found in the tree, return -1. The level starts at 0 for the root node and increases from top to bottom.
We have defined the following node C++ Node class for you:
class Node {
public:
int name;
Node* left = NULL;
Node* right = NULL; };
Note: In the test cases, the first line for input has multiple nodes and we will be inserting each one of them in your tree using an insert function. The second line is the key to be searched. The output is the level of the key in the BST.
Sample Input 1:
8 11 15 2 5 5
Sample Output 1:
2
Sample Input 2:
8 11 15 2 5 8
Sample Output 2:
0
int levelSearch(Node* root, int key)
{
//your code here
}
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int name;
Node* left = NULL;
Node* right = NULL;
};
Node* insert( Node* node, int key)
{
if (node == NULL)
{
Node*temp=new Node();
temp->name=key;
return temp;
}
if (key < node->name)
node->left = insert(node->left, key);
else if (key > node->name)
node->right = insert(node->right, key);
return node;
}
int levelSearch(Node* root, int key)
{
//your code here
int level=0;//here we are declaring initial level as 0
if (root == NULL) return 0;
queue<Node *> q; //declaring queue q;
q.push(root); //pushing root into q
while (q.empty() == false)
{
int Count = q.size(); //finding present size of queue at this
moment whole level will be in queue
level++;
while (Count > 0)
{
Node *node = q.front();
if(node->name==key) return level; //key found so returning
level
q.pop();
if (node->left != NULL)
q.push(node->left); // pushing left node
if (node->right != NULL)
q.push(node->right); // pushing right node
Count--;
}
cout << endl;
}
}
int main() {
Node *root=NULL;
int x;
char temp;
do{
scanf("%d%c", &x, &temp);
//cout<<x<<" ";
root=insert(root,x);
} while(temp!= ' ');
int numberToFind;
cin>>numberToFind;
cout<<levelSearch(root,numberToFind);
return 0;
}
Please upvote if you are
satisfied or if you have any doubts please post in comment
section
Write a function int levelSearch(Node* root, int key) that takes as input the root node of...
Coding Language: C++
Function Header: vector<vector<int>>
printFromButtom(TreeNode* root) {}
Definition for a binary tree node:
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
};
The Problem Complete the printFromButtom function that accepts a BST TreeNode and returns the nodes' value from left to right, level by level from leaf to root. This function will return vector<vector int which similar to a 2-D array. Function std: reverse (myvector.begin myVector en might be helpful. Definition for a binary tree node: struct...
You are given the root of a Binary Search Tree. Print the leaf elements of the tree starting from right to left. We have defined the following node C++ Node class for you: class Node { public: int name; Node* left = NULL; Node* right = NULL; }; Function to code: void printLeaves(Node* root); The first input in test cases are nodes of a tree which are inserted in that order. You don't need to implement insert. You have access...
Binary Search Tree Part A: The code attached in this document is a sample code to demonstrate insert operation in binary search tree. Please fill in the missing part for the insert method to make the program work. The expected output should be as follows. 20 30 40 50 60 70 80 Part B: Find Lowest Common Ancestor (LCA) of a Binary Search Tree. According to WikiPedia definition , The lowest common ancestor is defined between two nodes v and...
Write a method that determines the key of the successor of the root node in a binary search tree. For any input binary search tree, find the key of successor of the root node.Note: Successor is the node with the next highest key, should work for any binary search tree - not just the given example input. #include <iostream> using namespace std; class Node { private: int key; string val; Node* left; Node* right; friend class BinarySearchTree; }; class BinarySearchTree {...
package hw3; import java.util.LinkedList; /* *********************************************************************** * A simple BST with int keys and no values * * Complete each function below. * Write each function as a separate recursive definition (do not use more than one helper per function). * Depth of root==0. * Height of leaf==0. * Size of empty tree==0. * Height of empty tree=-1. * * TODO: complete the functions in this file. * DO NOT change the Node class. * DO NOT change the name...
C++ Binary Search Tree question. I heed help with the level 2
question please, as level 1 is already completed. I will rate the
answer a 100% thumbs up. I really appreciate the help!. Thank
you!
searching.cpp
#include <getopt.h>
#include <iostream>
#include <sstream>
#include <stdlib.h>
#include <unistd.h>
using namespace std;
// global variable for tree operations
// use to control tree maintenance operations
enum Mode { simple, randomised, avl } mode; // tree type
// returns size of tree
//...
using java to write,show me the output. please write some
common.
You CAN NOT use inbuild functions for Tree ADT operations.
using code below to finsih
public class Main
{
public static void main(String[] args) {
BinaryTree tree = new
BinaryTree();
tree.root = new Node(1);
tree.root.left = new Node(2);
tree.root.right = new Node(3);
tree.root.left.left = new Node(4);
tree.root.left.right = new Node(5);
tree.root.right.left = new Node(6);
tree.root.right.right = new Node(7);
tree.root.left.left.left = new Node(8);
tree.root.left.left .right= new Node(9);...
C++ Binary Search Tree question. I heed help with the level 2
question please, as level 1 is already completed. I will rate the
answer a 100% thumbs up. I really appreciate the help!. Thank
you!
searching.cpp
#include <getopt.h>
#include <iostream>
#include <sstream>
#include <stdlib.h>
#include <unistd.h>
using namespace std;
// global variable for tree operations
// use to control tree maintenance operations
enum Mode { simple, randomised, avl } mode; // tree type
// returns size of tree
//...
Using the following implementation of Tree class Node { public int iData; // data item (key) public double dData; // data item public Node leftChild; // this node's left child public Node rightChild; // this node's right child public void displayNode() // display ourself { System.out.print('{'); System.out.print(iData); System.out.print(", "); System.out.print(dData); System.out.print("} "); } } // end class Node //------------------------------------------------------------------ import java.io.IOException; import java.util.Stack; public class Tree { private Node root; // first node of tree // ------------------------------------------------------------- public Tree() // constructor { root = null; }...
1. Write a function in Tree class which returns true if and only if the tree satisfies the binary search tree property. The function’s header line is public boolean isValidBST() And in the attached code, you just need to finish the function after the comment: “//Instructor hint: please write your code here:” Make sure you execute your code, and the result in the main function after calling your function should be same as the prompt message I write. Clearly you...