To create a node for a binary search tree (BTNode, ) and to create a .pdf
•
0 likes•4 views
To create a node for a binary search tree (BTNode, ) and to create a binary search tree of comparable objects (Tree BTNode BTNode -data:E -left: BTNode -right: BTNode +BTNode (newData:E, newLeft: BTNode, newRight: BTNode) +getData():E +getLeft():BTNode +getRight():BTNode +getRightMostData():E +inOrderPrint():void +removeRightmost(): BTNode +setData(newData:E):void +setLeft(newleft: BTNode):void +setRight(newRight: BTNode):void needed for remove needed for remove Tree for Lab 7 Tree -root: 8TNode - numltems:int +Tree() +add(element:E):void +remove(element:E):boolean + remove +size():int + printTree():void Solution //BTNode.java public class BTNode { private E data; private BTNode left; private BTNode right; public BTNode(E newData, BTNode newLeft, BTNode newRight) { data = newData; left = newLeft; right = newRight; }//end constructor /** * Returns the data * @return The data */ public E getData() { return data; }//end getData /** * Returns the left link * @return the left link */ public BTNode getLeft() { return left; }//end getLeft /** * Returns the right link * @return the right link */ public BTNode getRight() { return right; }//end getRight /** * Prints the tree in order from left to right. */ public void inOrderPrint() { if (left != null){ left.inOrderPrint(); }//end left System.out.println(data); if(right != null){ right.inOrderPrint(); }//end right }//end inOrderPrint /** * Sets the data in the node * @param newData The new data to be passed */ public void setData(E newData) { data = newData; }//end setData /** * Sets a new link to left * @param newLeft the new link to go left */ public void setLeft(BTNode newLeft) { left = newLeft; }//end setLeft /** * Sets a new link to the right * @param newRight the new link to the right */ public void setRight(BTNode newRight) { right = newRight; }//end setRight public E getRightMostData() { if(right == null){ return data; } else { return right.getRightMostData(); }//end right == null if-else }//end getRightMostData public BTNode removeRightmost() { if (right == null){ return left; } else { right = right.removeRightmost(); return this; }//end if right == null if=-else }//end removeRightMost }//end BTNode ===================================================================== == //Tree.java public class Tree> { private BTNode root; private int numItems; /** * No-arg constructor */ public Tree() { root = null; numItems = 0; }//end constructor public void add(E element) { if (root == null) { root = new BTNode(element, null, null); }else{ BTNode cursor = root; boolean done = false; while(!done){ if (element.compareTo(cursor.getData()) <= 0){//cursor.getData().compareTo(element) > 0){ if (cursor.getLeft() == null) { cursor.setLeft(new BTNode(element,null,null)); done = true; } else { cursor = cursor.getLeft(); } //end left is null if-else }else{ if(cursor.getRight() == null){ cursor.setRight(new BTNode(element, null, null)); done = true; }else{ cursor = cursor.getRight(); }//end cursor.getRight if-else }/.
Report
Share
Report
Share
Download to read offline
Recommended
I have C++ question that I do not know how to do, Can you teach me t.pdf
I have C++ question that I do not know how to do, Can you teach me this question:
Draw a CLASS diagram for Binary Search Tree (BTS) :
can you explain me each step, thank you
Solution
//program to convert Binary Tree to Binary Search Tree
#include
#include
// A binary tree node structure
struct node
{
int data;
struct node *left;
struct node *right;
};
void storeInorder (struct node* node, int inorder[], int *index_ptr)
{
// Base Case
if (node == NULL)
return;
// first store the left subtree
storeInorder (node->left, inorder, index_ptr);
// Copy the root\'s data
inorder[*index_ptr] = node->data;
(*index_ptr)++; // increase index for next entry
// finally store the right subtree
storeInorder (node->right, inorder, index_ptr);
}
/* A helper function to count nodes in a Binary Tree */
int countNodes (struct node* root)
{
if (root == NULL)
return 0;
return countNodes (root->left) +
countNodes (root->right) + 1;
}
// Following function is needed for library function qsort()
int compare (const void * a, const void * b)
{
return ( *(int*)a - *(int*)b );
}
/* A helper function that copies contents of arr[] to Binary Tree.
This functon basically does Inorder traversal of Binary Tree and
one by one copy arr[] elements to Binary Tree nodes */
void arrayToBST (int *arr, struct node* root, int *index_ptr)
{
// Base Case
if (root == NULL)
return;
/* first update the left subtree */
arrayToBST (arr, root->left, index_ptr);
/* Now update root\'s data and increment index */
root->data = arr[*index_ptr];
(*index_ptr)++;
/* finally update the right subtree */
arrayToBST (arr, root->right, index_ptr);
}
// This function converts a given Binary Tree to BST
void binaryTreeToBST (struct node *root)
{
// base case: tree is empty
if(root == NULL)
return;
/* Count the number of nodes in Binary Tree so that
we know the size of temporary array to be created */
int n = countNodes (root);
// Create a temp array arr[] and store inorder traversal of tree in arr[]
int *arr = new int[n];
int i = 0;
storeInorder (root, arr, &i);
// Sort the array using library function for quick sort
qsort (arr, n, sizeof(arr[0]), compare);
// Copy array elements back to Binary Tree
i = 0;
arrayToBST (arr, root, &i);
// delete dynamically allocated memory to avoid meory leak
delete [] arr;
}
/* Utility function to create a new Binary Tree node */
struct node* newNode (int data)
{
struct node *temp = new struct node;
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return temp;
}
/* Utility function to print inorder traversal of Binary Tree */
void printInorder (struct node* node)
{
if (node == NULL)
return;
/* first recur on left child */
printInorder (node->left);
/* then print the data of node */
printf(\"%d \", node->data);
/* now recur on right child */
printInorder (node->right);
}
/* Driver function to test above functions */
int main()
{
struct node *root = NULL;
/* Constructing tree given in the above figure
10
/ \\
30 15
/ \\
20 5 */
root = newNode(10);
root->left = newNode(30.
Data Structures and Agorithm: DS 14 Binary Expression Tree.pptx
Data Structures and Agorithm: DS 14 Binary Expression Tree.pptx
The following is to be written in JavaThe following is the BSTree.pdf
The following is to be written in Java:
The following is the BSTree.java I have written. Use this code and extend it to achieve the
problems listed above:
import java.io.*;
import java.util.*;
class BSTNode {
BSTNode left, right;
Comparable data;
public BSTNode(){
left = null;
right = null;
data = 0;
}
/* Constructor */
public BSTNode(Comparable n){
left = null;
right = null;
data = n;
}
public void setLeft(BSTNode n){
left = n;
}
public void setRight(BSTNode n){
right = n;
}
public BSTNode getLeft(){
return left;
}
public BSTNode getRight(){
return right;
}
public void setData(int d){
data = d;
}
public Comparable getData(){
return data;
}
}
class BST {
private BSTNode root;
/* Constructor */
public BST(){
root = null;
}
/* Functions to insert data */
public void insert(Comparable data){
if (root == null){
root = new BSTNode(data);
}
else insert(root, data);
}
/* Function to insert data recursively */
private void insert(BSTNode node, Comparable data){
//if (node.getData().equals(data)) thr();
if (data.compareTo(node.getData()) < 0){
//when data < node\'s data
//add data as left child of node if it doesnt have one
//else insert into node\'s left subtree
if (node.getLeft() == null) node.setLeft(new BSTNode(data));
else insert(node.getLeft(), data);
} else {
//when data > node\'s data
//insert data as right child of node if it doesnt have one
//else insert into node\'s right subtree
if (node.getRight() == null) node.setRight(new BSTNode(data));
else insert(node.getRight(), data);
}
}
public boolean search(Comparable data) {
return search(root, data);
}
private static boolean search(BSTNode node, Comparable data) {
if (node == null) return false;
if (node.getData().equals(data)) return true;
if (data.compareTo(node.getData()) < 0) {
// data < this node\'s key; look in left subtree
return search(node.getLeft(), data);
}
else {
// data > this node\'s key; look in right subtree
return search(node.getRight(), data);
}
}
/* Function for inorder traversal */
public void inorder(){
inorder(root);
}
private void inorder(BSTNode r){
if (r != null){
inorder(r.getLeft());
System.out.print(r.getData() +\" \");
inorder(r.getRight());
}
}
}
public class BSTree {
public static void main(String[] args) {
BST bst = new BST();
int[] x = {4,2,6,1,3,5,7,8,12,15,10,13,14,9};
for(int i=0;i
Solution
REDBLACK.java
/*
--------------------------------------------------------------------------------------------------------------------
-----------------------------------------------
RBBST.java.
Given the following codepackage data1;import java.util.;p.pdf
Given the following code
package data1;
import java.util.*;
/*public class BST> implementing a set ADT and containing the following:
* private inner class BinaryNode representing a node with a (possibly) left child and a (possibly)
right child
** instance fields BinaryNode root, int size
* contains/insert/remove method - w/ O(height) complexity
** size O(1), isEmpty O(1), clear O(1),
*** findMin, findMax, findHeight methods - w/ O(height) complexity
**** toString() method printing set (in-order traversal) and the tree (BFS traversal)
**
*/
publicclass BST> {
private BinaryNode root;
privateint size;
//Search opertion of Set ADT
publicboolean contains(E value) {
return contains(root, value);
}
//Insert opertion of Set ADT
publicvoid insert(E value) {
root = insert(root, value);
size++;
}
//Remove operation of Set ADT
publicvoid remove(E value){
root = remove(root, value);
size--;
}
publicint size(){
return size;
}
publicboolean isEmpty(){
return root == null;
}
publicvoid clear(){
root = null;
size = 0;
}
public E findMin(){
return findMin(root);
}
public E findMax(){
return findMax(root);
}
publicint findHeight(){
return root.height();
}
public String toString(){
if(root == null)
return "set {} stored in an empty tree.\n";
String elements = root.inOrder().toString();
return "set {" + elements.substring(1,elements.length()-1) + "} stored in tree \n" + root;
}
private E findMin(BinaryNode node){
if(node == null)
returnnull;
if(node.left == null)
return node.element;
return findMin(node.left);
}
private E findMax(BinaryNode node){
if(node == null)
returnnull;
if(node.right == null)
return node.element;
return findMax(node.right);
}
privateboolean contains(BinaryNode node, E value) {
if (node == null)//node represents an empty substree
returnfalse;
int comparisonResult = value.compareTo(node.element);
if(comparisonResult < 0)//if value is less than root's value
return contains(node.left, value);
if(comparisonResult > 0)//if value is greater than root's value
return contains(node.right, value);
returntrue;//successful search
}
private BinaryNode insert(BinaryNode node, E value) {
if (node == null)//base case: empty tree
returnnew BinaryNode<>(value);
if (value.compareTo(node.element) < 0)
node.left = insert(node.left, value);//insert recursively to left-subtree
elseif (value.compareTo(node.element) > 0)
node.right = insert(node.right, value);//insert recursively to right-subtree
else {//duplicate value cannot be inserted in a BST implementing the Set ADT
size--;//insertion failed!
//System.out.print("BST.insert: Warning: " + value + " is already stored in the tree \n" + node);
}
return node;
}
private BinaryNode remove(BinaryNode node, E value) {
if (node == null) {//base case: empty tree
System.out.println("BST.remove: Warning: " + value + " doesn't exist in the tree.");
size++;//removal failed!
return node;
}
if (value.compareTo(node.element) < 0)
node.left = remove(node.left, value);
elseif (value.compareTo(node.element) > 0)
node.right = remov.
There is BinarySearchTree class. When removing a node from a BST, we.pdf
There is BinarySearchTree class. When removing a node from a BST, we can replace it with
either its predecessor or its successor. Complete the predecessor() method
so that it returns the node that comes immediately before e. Hint: the work needed to find the
predecessor is a mirror image of what is required to find a node\'s
successor, so use successor() as a resource.
BinarySearchTree class:
Solution
import java.util.AbstractSet;
import java.util.Iterator;
public class BinarySearchTree> extends AbstractSet {
protected BTNode root;
protected int size;
/**
* Initializes this BinarySearchTree object to be empty, to contain only
* elements of type E, to be ordered by the Comparable interface, and to
* contain no duplicate elements.
*/
public BinarySearchTree() {
root = null;
size = 0;
}
/**
* Initializes this BinarySearchTree object to contain a shallow copy of a
* specified BinarySearchTree object. The worstTime(n) is O(n), where n is the
* number of elements in the specified BinarySearchTree object.
*
* @param otherTree - the specified BinarySearchTree object that this
* BinarySearchTree object will be assigned a shallow copy of.
*/
public BinarySearchTree(BinarySearchTree otherTree) {
root = copy(otherTree.root, null);
size = otherTree.size;
}
protected BTNode copy(BTNode p, BTNode parent) {
if (p != null) {
BTNode q = new BTNode(p.element, parent);
q.left = copy(p.left, q);
q.right = copy(p.right, q);
return q;
}
return null;
} // method copy
/**
* Finds the predecessor of a specified BTNode object in this BinarySearchTree. The
worstTime(n) is O(n) and
* averageTime(n) is constant.
*
* @param e - the BTNode object whose successor is to be found.
* @return the successor of e, if e has a successor; otherwise, return null.
*/
protected BTNode predecessor(BTNode e) {
if (e == null) {
return null;
} else if (e.left != null) {
// successor is leftmost BTNode in right subtree of e
BTNode p = e.left;
while (p.right != null) {
p = p.right;
}
return p;
} // e has a right child
else {
// go up the tree to the right as far as possible, then go up
// to the left.
BTNode p = e.parent;
BTNode ch = e;
while ((p != null) && (ch == p.left)) {
ch = p;
p = p.parent;
} // while
return p;
} // e has no left child
// method successor
}
@SuppressWarnings(\"unchecked\")
@Override
public boolean equals(Object obj) {
if (!(obj instanceof BinarySearchTree)) {
return false;
}
return equals(root, ((BinarySearchTree) obj).root);
} // method 1-parameter equals
public boolean equals(BTNode p, BTNode q) {
if ((p == null) || (q == null)) {
return p == q;
}
if (!p.element.equals(q.element)) {
return false;
}
if (equals(p.left, q.left) && equals(p.right, q.right)) {
return true;
}
return false;
}
/**
* Returns the size of this BinarySearchTree object.
*
* @return the size of this BinarySearchTree object.
*/
@Override
public int size() {
return size;
}
/**
* Iterator method will be implemented for a future
*
* @return an iterator positioned at the smallest element in this
* Bina.
Please read the comment ins codeExpressionTree.java-------------.pdf
Please read the comment ins code
ExpressionTree.java
----------------------------------
/**
* This is the class for Expression Tree.
* Used to create Expression Tree and Evaluate it
*/
/**
* Following logic is used to construct a Tree
* Here we use stack for Preparing Tree
* Loop through given Expression String
* If Character is Operand , Create node and push to stack
* If Character is Operator then
* 1)Create Node for Operator
* 2)Pop 2 nodes from Stack and Made
* OpretorNode--> left == first node pop
* OpretorNode--> right == second node pop
* At the end of creation of Expression Tree, Stack have only one node , which is root of
Expression tree
*/
/** Class ExpressionTree **/
class ExpressionTree
{
/** class TreeNode
* Stored Character ==> Digit(0..9) or a Operator +,-,*,/
* Left Node and Right Node
*
* **/
class TreeNode
{
char data;
TreeNode left, right;
/** constructor **/
public TreeNode(char data)
{
this.data = data;
this.left = null;
this.right = null;
}
}
/** class StackNode **/
class StackNode
{
TreeNode treeNode;
StackNode next;
/** constructor **/
public StackNode(TreeNode treeNode)
{
this.treeNode = treeNode;
next = null;
}
}
private static StackNode top;
/** constructor
* Constructor takes input string like \"+-+7*935*82*625\"
* Input should be in Prefix notation
* **/
public ExpressionTree(String expression)
{
top = null;
//Call Method for prepare expression tree
buildTree(expression);
}
/** function to clear tree **/
public void clear()
{
top = null;
}
/** function to push a node **/
private void push(TreeNode ptr)
{
if (top == null)
top = new StackNode(ptr);
else
{
StackNode nptr = new StackNode(ptr);
nptr.next = top;
top = nptr;
}
}
/** function to pop a node
* When it find operator pop 2 elements from Stack
*
* **/
private TreeNode pop()
{
if (top == null)
throw new RuntimeException(\"Underflow\");
else
{
TreeNode ptr = top.treeNode;
top = top.next;
return ptr;
}
}
/** function to get top node **/
private TreeNode peek()
{
return top.treeNode;
}
/** function to insert character **/
private void insert(char val)
{
try
{
//If Operand , Create node and push to Stack
if (isDigit(val))
{
TreeNode nptr = new TreeNode(val);
push(nptr);
}
//If Operator , Create node and popup 2 elements and make them its right and left
else if (isOperator(val))
{
TreeNode nptr = new TreeNode(val);
nptr.left = pop();
nptr.right = pop();
push(nptr);
}
}
catch (Exception e)
{
System.out.println(\"Invalid Expression\");
}
}
/** function to check if digit **/
private boolean isDigit(char ch)
{
return ch >= \'0\' && ch <= \'9\';
}
/** function to check if operator **/
private boolean isOperator(char ch)
{
return ch == \'+\' || ch == \'-\' || ch == \'*\' || ch == \'/\';
}
/** function to convert character to digit **/
private int toDigit(char ch)
{
return ch - \'0\';
}
/** function to build tree from input */
public void buildTree(String eqn)
{
for (int i = eqn.length() - 1; i >= 0; i--)
insert(eqn.charAt(i));
}
/** function to evaluate tree */
public dou.
Assignment 9 (Parent reference for BST) Redefine TreeNode by adding .pdf
Assignment 9 (Parent reference for BST) Redefine TreeNode by adding a reference to a node’s
parent, as shown below:
BST.TreeNode
#element
#left : TreeNode
#right: TreeNode
#parent: TreeNode
Implement the insert and delete methods in BST class to update the parent for each node in the
tree.
Add the following new method in BST:
/** Return the node for the specific element.
* Return null if the element is not in the tree. */
private TreeNode getNode(E element)
/** Returns true if the node for the element is a lead */
private boolean isLeaf(E element)
/** Returns the path of the element from the specific element to the root in an array list */
public ArrayList getPath(E e)
Write a test program that prompts the user to enter 10 integers, adds them to the tree, deletes the
first integer from the tree, and displays the paths for all leaf nodes.
Sample run
Enter 10 integers :
45 54 67 56 50 45 23 59 23 67
[50, 54, 23]
[59, 56, 67, 54, 23]
Solution
import java.util.NoSuchElementException; public class TreeSet> implements Set {
private TreeNode root; private int size; // Constructs an empty set. public
TreeSet() { root = null; size = 0; } // Adds the given value to this
set, if it was not already in the set. // If the element is already a member of this set, adding it
again has no effect. public void add(E value) { root = add(root, value); }
// private recursive helper for add // uses the \"x = change(x)\" pattern: // pass in
current state of root // return out desired new state of root private TreeNode
add(TreeNode node, E value) { if (node == null) { node = new
TreeNode(value); // reached dead end; put new node here size++; }
else if (value.compareTo(node.data) > 0) { node.right = add(node.right, value);
} else if (value.compareTo(node.data) < 0) { node.left = add(node.left,
value); } // else a duplicate; do nothing return node; } // Returns
true if this set contains the given element value. public boolean contains(E value) {
return contains(root, value); } // private recursive helper for contains private
boolean contains(TreeNode node, E value) { if (node == null) { return
false; } else if (value.compareTo(node.data) > 0) { return
contains(node.right, value); } else if (value.compareTo(node.data) < 0) {
return contains(node.left, value); } else { // value.equals(root.data);
found it! return true; } } // Returns the minimum value in this
set. // Throws a NoSuchElementException if this set is empty. public E getMin() {
if (root == null) { throw new NoSuchElementException(\"empty tree\");
} return getMin(root); } // private recursive helper for getMin
private E getMin(TreeNode node) { if (node.left == null) { return
node.data; } else { return getMin(node.left); } }
// Returns true if this set does not contain any elements. public boolean isEmpty() {
return size == 0; } // Prints all elements of this tree in a left-to-right order (in-order)
traversal. public void print() { print(root); } // private recursive helper
for print private void print(TreeNode .
create a binary search tree from an empty one by adding the key valu.pdf
create a binary search tree from an empty one by adding the key value alphabetically in c++
Solution
//Binary Search Tree Program
#include
#include
using namespace std;
class BinarySearchTree
{
private:
struct tree_node //structure to hold Binary search tree
{
tree_node* left;
tree_node* right;
int data;
};
tree_node* root;
public:
BinarySearchTree() //constructor of Binary search tree
{
root = NULL;
}
//function declarations
bool isEmpty() const { return root==NULL; }
void print_inorder();
void inorder(tree_node*);
void print_preorder();
void preorder(tree_node*);
void print_postorder();
void postorder(tree_node*);
void insert(int);
void remove(int);
};
// Smaller elements go left
// larger elements go right
void BinarySearchTree::insert(int d) //insert function to BST
{
tree_node* t = new tree_node;
tree_node* parent;
t->data = d;
t->left = NULL;
t->right = NULL;
parent = NULL;
// is this a new tree?
if(isEmpty()) root = t;
else
{
//Note: ALL insertions are as leaf nodes
tree_node* curr;
curr = root;
// Find the Node\'s parent
while(curr)
{
parent = curr;
if(t->data > curr->data) curr = curr->right;
else curr = curr->left;
}
if(t->data < parent->data)
parent->left = t;
else
parent->right = t;
}
}
void BinarySearchTree::remove(int d)
{
//Locate the element
bool found = false;
if(isEmpty())
{
cout<<\" This Tree is empty! \"<data == d)
{
found = true;
break;
}
else
{
parent = curr;
if(d>curr->data) curr = curr->right;
else curr = curr->left;
}
}
if(!found)
{
cout<<\" Data not found! \"<left == NULL && curr->right != NULL)|| (curr->left !=
NULL
&& curr->right == NULL))
{
if(curr->left == NULL && curr->right != NULL)
{
if(parent->left == curr)
{
parent->left = curr->right;
delete curr;
}
else
{
parent->right = curr->right;
delete curr;
}
}
else // left child present, no right child
{
if(parent->left == curr)
{
parent->left = curr->left;
delete curr;
}
else
{
parent->right = curr->left;
delete curr;
}
}
return;
}
//We\'re looking at a leaf node
if( curr->left == NULL && curr->right == NULL)
{
if(parent->left == curr) parent->left = NULL;
else parent->right = NULL;
delete curr;
return;
}
//Node with 2 children
// replace node with smallest value in right subtree
if (curr->left != NULL && curr->right != NULL)
{
tree_node* chkr;
chkr = curr->right;
if((chkr->left == NULL) && (chkr->right == NULL))
{
curr = chkr;
delete chkr;
curr->right = NULL;
}
else // right child has children
{
//if the node\'s right child has a left child
// Move all the way down left to locate smallest element
if((curr->right)->left != NULL)
{
tree_node* lcurr;
tree_node* lcurrp;
lcurrp = curr->right;
lcurr = (curr->right)->left;
while(lcurr->left != NULL)
{
lcurrp = lcurr;
lcurr = lcurr->left;
}
curr->data = lcurr->data;
delete lcurr;
lcurrp->left = NULL;
}
else
{
tree_node* tmp;
tmp = curr->right;
curr->data = tmp->data;
curr->right = tmp->right;
delete tmp;
}
}
return;
}
}
void BinarySearchTree::print_inorder()
{
inorder(root);
}
void BinarySearchTree::inorder(tree_node* p) .
Recommended
I have C++ question that I do not know how to do, Can you teach me t.pdf
I have C++ question that I do not know how to do, Can you teach me this question:
Draw a CLASS diagram for Binary Search Tree (BTS) :
can you explain me each step, thank you
Solution
//program to convert Binary Tree to Binary Search Tree
#include
#include
// A binary tree node structure
struct node
{
int data;
struct node *left;
struct node *right;
};
void storeInorder (struct node* node, int inorder[], int *index_ptr)
{
// Base Case
if (node == NULL)
return;
// first store the left subtree
storeInorder (node->left, inorder, index_ptr);
// Copy the root\'s data
inorder[*index_ptr] = node->data;
(*index_ptr)++; // increase index for next entry
// finally store the right subtree
storeInorder (node->right, inorder, index_ptr);
}
/* A helper function to count nodes in a Binary Tree */
int countNodes (struct node* root)
{
if (root == NULL)
return 0;
return countNodes (root->left) +
countNodes (root->right) + 1;
}
// Following function is needed for library function qsort()
int compare (const void * a, const void * b)
{
return ( *(int*)a - *(int*)b );
}
/* A helper function that copies contents of arr[] to Binary Tree.
This functon basically does Inorder traversal of Binary Tree and
one by one copy arr[] elements to Binary Tree nodes */
void arrayToBST (int *arr, struct node* root, int *index_ptr)
{
// Base Case
if (root == NULL)
return;
/* first update the left subtree */
arrayToBST (arr, root->left, index_ptr);
/* Now update root\'s data and increment index */
root->data = arr[*index_ptr];
(*index_ptr)++;
/* finally update the right subtree */
arrayToBST (arr, root->right, index_ptr);
}
// This function converts a given Binary Tree to BST
void binaryTreeToBST (struct node *root)
{
// base case: tree is empty
if(root == NULL)
return;
/* Count the number of nodes in Binary Tree so that
we know the size of temporary array to be created */
int n = countNodes (root);
// Create a temp array arr[] and store inorder traversal of tree in arr[]
int *arr = new int[n];
int i = 0;
storeInorder (root, arr, &i);
// Sort the array using library function for quick sort
qsort (arr, n, sizeof(arr[0]), compare);
// Copy array elements back to Binary Tree
i = 0;
arrayToBST (arr, root, &i);
// delete dynamically allocated memory to avoid meory leak
delete [] arr;
}
/* Utility function to create a new Binary Tree node */
struct node* newNode (int data)
{
struct node *temp = new struct node;
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return temp;
}
/* Utility function to print inorder traversal of Binary Tree */
void printInorder (struct node* node)
{
if (node == NULL)
return;
/* first recur on left child */
printInorder (node->left);
/* then print the data of node */
printf(\"%d \", node->data);
/* now recur on right child */
printInorder (node->right);
}
/* Driver function to test above functions */
int main()
{
struct node *root = NULL;
/* Constructing tree given in the above figure
10
/ \\
30 15
/ \\
20 5 */
root = newNode(10);
root->left = newNode(30.
Data Structures and Agorithm: DS 14 Binary Expression Tree.pptx
Data Structures and Agorithm: DS 14 Binary Expression Tree.pptx
The following is to be written in JavaThe following is the BSTree.pdf
The following is to be written in Java:
The following is the BSTree.java I have written. Use this code and extend it to achieve the
problems listed above:
import java.io.*;
import java.util.*;
class BSTNode {
BSTNode left, right;
Comparable data;
public BSTNode(){
left = null;
right = null;
data = 0;
}
/* Constructor */
public BSTNode(Comparable n){
left = null;
right = null;
data = n;
}
public void setLeft(BSTNode n){
left = n;
}
public void setRight(BSTNode n){
right = n;
}
public BSTNode getLeft(){
return left;
}
public BSTNode getRight(){
return right;
}
public void setData(int d){
data = d;
}
public Comparable getData(){
return data;
}
}
class BST {
private BSTNode root;
/* Constructor */
public BST(){
root = null;
}
/* Functions to insert data */
public void insert(Comparable data){
if (root == null){
root = new BSTNode(data);
}
else insert(root, data);
}
/* Function to insert data recursively */
private void insert(BSTNode node, Comparable data){
//if (node.getData().equals(data)) thr();
if (data.compareTo(node.getData()) < 0){
//when data < node\'s data
//add data as left child of node if it doesnt have one
//else insert into node\'s left subtree
if (node.getLeft() == null) node.setLeft(new BSTNode(data));
else insert(node.getLeft(), data);
} else {
//when data > node\'s data
//insert data as right child of node if it doesnt have one
//else insert into node\'s right subtree
if (node.getRight() == null) node.setRight(new BSTNode(data));
else insert(node.getRight(), data);
}
}
public boolean search(Comparable data) {
return search(root, data);
}
private static boolean search(BSTNode node, Comparable data) {
if (node == null) return false;
if (node.getData().equals(data)) return true;
if (data.compareTo(node.getData()) < 0) {
// data < this node\'s key; look in left subtree
return search(node.getLeft(), data);
}
else {
// data > this node\'s key; look in right subtree
return search(node.getRight(), data);
}
}
/* Function for inorder traversal */
public void inorder(){
inorder(root);
}
private void inorder(BSTNode r){
if (r != null){
inorder(r.getLeft());
System.out.print(r.getData() +\" \");
inorder(r.getRight());
}
}
}
public class BSTree {
public static void main(String[] args) {
BST bst = new BST();
int[] x = {4,2,6,1,3,5,7,8,12,15,10,13,14,9};
for(int i=0;i
Solution
REDBLACK.java
/*
--------------------------------------------------------------------------------------------------------------------
-----------------------------------------------
RBBST.java.
Given the following codepackage data1;import java.util.;p.pdf
Given the following code
package data1;
import java.util.*;
/*public class BST> implementing a set ADT and containing the following:
* private inner class BinaryNode representing a node with a (possibly) left child and a (possibly)
right child
** instance fields BinaryNode root, int size
* contains/insert/remove method - w/ O(height) complexity
** size O(1), isEmpty O(1), clear O(1),
*** findMin, findMax, findHeight methods - w/ O(height) complexity
**** toString() method printing set (in-order traversal) and the tree (BFS traversal)
**
*/
publicclass BST> {
private BinaryNode root;
privateint size;
//Search opertion of Set ADT
publicboolean contains(E value) {
return contains(root, value);
}
//Insert opertion of Set ADT
publicvoid insert(E value) {
root = insert(root, value);
size++;
}
//Remove operation of Set ADT
publicvoid remove(E value){
root = remove(root, value);
size--;
}
publicint size(){
return size;
}
publicboolean isEmpty(){
return root == null;
}
publicvoid clear(){
root = null;
size = 0;
}
public E findMin(){
return findMin(root);
}
public E findMax(){
return findMax(root);
}
publicint findHeight(){
return root.height();
}
public String toString(){
if(root == null)
return "set {} stored in an empty tree.\n";
String elements = root.inOrder().toString();
return "set {" + elements.substring(1,elements.length()-1) + "} stored in tree \n" + root;
}
private E findMin(BinaryNode node){
if(node == null)
returnnull;
if(node.left == null)
return node.element;
return findMin(node.left);
}
private E findMax(BinaryNode node){
if(node == null)
returnnull;
if(node.right == null)
return node.element;
return findMax(node.right);
}
privateboolean contains(BinaryNode node, E value) {
if (node == null)//node represents an empty substree
returnfalse;
int comparisonResult = value.compareTo(node.element);
if(comparisonResult < 0)//if value is less than root's value
return contains(node.left, value);
if(comparisonResult > 0)//if value is greater than root's value
return contains(node.right, value);
returntrue;//successful search
}
private BinaryNode insert(BinaryNode node, E value) {
if (node == null)//base case: empty tree
returnnew BinaryNode<>(value);
if (value.compareTo(node.element) < 0)
node.left = insert(node.left, value);//insert recursively to left-subtree
elseif (value.compareTo(node.element) > 0)
node.right = insert(node.right, value);//insert recursively to right-subtree
else {//duplicate value cannot be inserted in a BST implementing the Set ADT
size--;//insertion failed!
//System.out.print("BST.insert: Warning: " + value + " is already stored in the tree \n" + node);
}
return node;
}
private BinaryNode remove(BinaryNode node, E value) {
if (node == null) {//base case: empty tree
System.out.println("BST.remove: Warning: " + value + " doesn't exist in the tree.");
size++;//removal failed!
return node;
}
if (value.compareTo(node.element) < 0)
node.left = remove(node.left, value);
elseif (value.compareTo(node.element) > 0)
node.right = remov.
There is BinarySearchTree class. When removing a node from a BST, we.pdf
There is BinarySearchTree class. When removing a node from a BST, we can replace it with
either its predecessor or its successor. Complete the predecessor() method
so that it returns the node that comes immediately before e. Hint: the work needed to find the
predecessor is a mirror image of what is required to find a node\'s
successor, so use successor() as a resource.
BinarySearchTree class:
Solution
import java.util.AbstractSet;
import java.util.Iterator;
public class BinarySearchTree> extends AbstractSet {
protected BTNode root;
protected int size;
/**
* Initializes this BinarySearchTree object to be empty, to contain only
* elements of type E, to be ordered by the Comparable interface, and to
* contain no duplicate elements.
*/
public BinarySearchTree() {
root = null;
size = 0;
}
/**
* Initializes this BinarySearchTree object to contain a shallow copy of a
* specified BinarySearchTree object. The worstTime(n) is O(n), where n is the
* number of elements in the specified BinarySearchTree object.
*
* @param otherTree - the specified BinarySearchTree object that this
* BinarySearchTree object will be assigned a shallow copy of.
*/
public BinarySearchTree(BinarySearchTree otherTree) {
root = copy(otherTree.root, null);
size = otherTree.size;
}
protected BTNode copy(BTNode p, BTNode parent) {
if (p != null) {
BTNode q = new BTNode(p.element, parent);
q.left = copy(p.left, q);
q.right = copy(p.right, q);
return q;
}
return null;
} // method copy
/**
* Finds the predecessor of a specified BTNode object in this BinarySearchTree. The
worstTime(n) is O(n) and
* averageTime(n) is constant.
*
* @param e - the BTNode object whose successor is to be found.
* @return the successor of e, if e has a successor; otherwise, return null.
*/
protected BTNode predecessor(BTNode e) {
if (e == null) {
return null;
} else if (e.left != null) {
// successor is leftmost BTNode in right subtree of e
BTNode p = e.left;
while (p.right != null) {
p = p.right;
}
return p;
} // e has a right child
else {
// go up the tree to the right as far as possible, then go up
// to the left.
BTNode p = e.parent;
BTNode ch = e;
while ((p != null) && (ch == p.left)) {
ch = p;
p = p.parent;
} // while
return p;
} // e has no left child
// method successor
}
@SuppressWarnings(\"unchecked\")
@Override
public boolean equals(Object obj) {
if (!(obj instanceof BinarySearchTree)) {
return false;
}
return equals(root, ((BinarySearchTree) obj).root);
} // method 1-parameter equals
public boolean equals(BTNode p, BTNode q) {
if ((p == null) || (q == null)) {
return p == q;
}
if (!p.element.equals(q.element)) {
return false;
}
if (equals(p.left, q.left) && equals(p.right, q.right)) {
return true;
}
return false;
}
/**
* Returns the size of this BinarySearchTree object.
*
* @return the size of this BinarySearchTree object.
*/
@Override
public int size() {
return size;
}
/**
* Iterator method will be implemented for a future
*
* @return an iterator positioned at the smallest element in this
* Bina.
Please read the comment ins codeExpressionTree.java-------------.pdf
Please read the comment ins code
ExpressionTree.java
----------------------------------
/**
* This is the class for Expression Tree.
* Used to create Expression Tree and Evaluate it
*/
/**
* Following logic is used to construct a Tree
* Here we use stack for Preparing Tree
* Loop through given Expression String
* If Character is Operand , Create node and push to stack
* If Character is Operator then
* 1)Create Node for Operator
* 2)Pop 2 nodes from Stack and Made
* OpretorNode--> left == first node pop
* OpretorNode--> right == second node pop
* At the end of creation of Expression Tree, Stack have only one node , which is root of
Expression tree
*/
/** Class ExpressionTree **/
class ExpressionTree
{
/** class TreeNode
* Stored Character ==> Digit(0..9) or a Operator +,-,*,/
* Left Node and Right Node
*
* **/
class TreeNode
{
char data;
TreeNode left, right;
/** constructor **/
public TreeNode(char data)
{
this.data = data;
this.left = null;
this.right = null;
}
}
/** class StackNode **/
class StackNode
{
TreeNode treeNode;
StackNode next;
/** constructor **/
public StackNode(TreeNode treeNode)
{
this.treeNode = treeNode;
next = null;
}
}
private static StackNode top;
/** constructor
* Constructor takes input string like \"+-+7*935*82*625\"
* Input should be in Prefix notation
* **/
public ExpressionTree(String expression)
{
top = null;
//Call Method for prepare expression tree
buildTree(expression);
}
/** function to clear tree **/
public void clear()
{
top = null;
}
/** function to push a node **/
private void push(TreeNode ptr)
{
if (top == null)
top = new StackNode(ptr);
else
{
StackNode nptr = new StackNode(ptr);
nptr.next = top;
top = nptr;
}
}
/** function to pop a node
* When it find operator pop 2 elements from Stack
*
* **/
private TreeNode pop()
{
if (top == null)
throw new RuntimeException(\"Underflow\");
else
{
TreeNode ptr = top.treeNode;
top = top.next;
return ptr;
}
}
/** function to get top node **/
private TreeNode peek()
{
return top.treeNode;
}
/** function to insert character **/
private void insert(char val)
{
try
{
//If Operand , Create node and push to Stack
if (isDigit(val))
{
TreeNode nptr = new TreeNode(val);
push(nptr);
}
//If Operator , Create node and popup 2 elements and make them its right and left
else if (isOperator(val))
{
TreeNode nptr = new TreeNode(val);
nptr.left = pop();
nptr.right = pop();
push(nptr);
}
}
catch (Exception e)
{
System.out.println(\"Invalid Expression\");
}
}
/** function to check if digit **/
private boolean isDigit(char ch)
{
return ch >= \'0\' && ch <= \'9\';
}
/** function to check if operator **/
private boolean isOperator(char ch)
{
return ch == \'+\' || ch == \'-\' || ch == \'*\' || ch == \'/\';
}
/** function to convert character to digit **/
private int toDigit(char ch)
{
return ch - \'0\';
}
/** function to build tree from input */
public void buildTree(String eqn)
{
for (int i = eqn.length() - 1; i >= 0; i--)
insert(eqn.charAt(i));
}
/** function to evaluate tree */
public dou.
Assignment 9 (Parent reference for BST) Redefine TreeNode by adding .pdf
Assignment 9 (Parent reference for BST) Redefine TreeNode by adding a reference to a node’s
parent, as shown below:
BST.TreeNode
#element
#left : TreeNode
#right: TreeNode
#parent: TreeNode
Implement the insert and delete methods in BST class to update the parent for each node in the
tree.
Add the following new method in BST:
/** Return the node for the specific element.
* Return null if the element is not in the tree. */
private TreeNode getNode(E element)
/** Returns true if the node for the element is a lead */
private boolean isLeaf(E element)
/** Returns the path of the element from the specific element to the root in an array list */
public ArrayList getPath(E e)
Write a test program that prompts the user to enter 10 integers, adds them to the tree, deletes the
first integer from the tree, and displays the paths for all leaf nodes.
Sample run
Enter 10 integers :
45 54 67 56 50 45 23 59 23 67
[50, 54, 23]
[59, 56, 67, 54, 23]
Solution
import java.util.NoSuchElementException; public class TreeSet> implements Set {
private TreeNode root; private int size; // Constructs an empty set. public
TreeSet() { root = null; size = 0; } // Adds the given value to this
set, if it was not already in the set. // If the element is already a member of this set, adding it
again has no effect. public void add(E value) { root = add(root, value); }
// private recursive helper for add // uses the \"x = change(x)\" pattern: // pass in
current state of root // return out desired new state of root private TreeNode
add(TreeNode node, E value) { if (node == null) { node = new
TreeNode(value); // reached dead end; put new node here size++; }
else if (value.compareTo(node.data) > 0) { node.right = add(node.right, value);
} else if (value.compareTo(node.data) < 0) { node.left = add(node.left,
value); } // else a duplicate; do nothing return node; } // Returns
true if this set contains the given element value. public boolean contains(E value) {
return contains(root, value); } // private recursive helper for contains private
boolean contains(TreeNode node, E value) { if (node == null) { return
false; } else if (value.compareTo(node.data) > 0) { return
contains(node.right, value); } else if (value.compareTo(node.data) < 0) {
return contains(node.left, value); } else { // value.equals(root.data);
found it! return true; } } // Returns the minimum value in this
set. // Throws a NoSuchElementException if this set is empty. public E getMin() {
if (root == null) { throw new NoSuchElementException(\"empty tree\");
} return getMin(root); } // private recursive helper for getMin
private E getMin(TreeNode node) { if (node.left == null) { return
node.data; } else { return getMin(node.left); } }
// Returns true if this set does not contain any elements. public boolean isEmpty() {
return size == 0; } // Prints all elements of this tree in a left-to-right order (in-order)
traversal. public void print() { print(root); } // private recursive helper
for print private void print(TreeNode .
create a binary search tree from an empty one by adding the key valu.pdf
create a binary search tree from an empty one by adding the key value alphabetically in c++
Solution
//Binary Search Tree Program
#include
#include
using namespace std;
class BinarySearchTree
{
private:
struct tree_node //structure to hold Binary search tree
{
tree_node* left;
tree_node* right;
int data;
};
tree_node* root;
public:
BinarySearchTree() //constructor of Binary search tree
{
root = NULL;
}
//function declarations
bool isEmpty() const { return root==NULL; }
void print_inorder();
void inorder(tree_node*);
void print_preorder();
void preorder(tree_node*);
void print_postorder();
void postorder(tree_node*);
void insert(int);
void remove(int);
};
// Smaller elements go left
// larger elements go right
void BinarySearchTree::insert(int d) //insert function to BST
{
tree_node* t = new tree_node;
tree_node* parent;
t->data = d;
t->left = NULL;
t->right = NULL;
parent = NULL;
// is this a new tree?
if(isEmpty()) root = t;
else
{
//Note: ALL insertions are as leaf nodes
tree_node* curr;
curr = root;
// Find the Node\'s parent
while(curr)
{
parent = curr;
if(t->data > curr->data) curr = curr->right;
else curr = curr->left;
}
if(t->data < parent->data)
parent->left = t;
else
parent->right = t;
}
}
void BinarySearchTree::remove(int d)
{
//Locate the element
bool found = false;
if(isEmpty())
{
cout<<\" This Tree is empty! \"<data == d)
{
found = true;
break;
}
else
{
parent = curr;
if(d>curr->data) curr = curr->right;
else curr = curr->left;
}
}
if(!found)
{
cout<<\" Data not found! \"<left == NULL && curr->right != NULL)|| (curr->left !=
NULL
&& curr->right == NULL))
{
if(curr->left == NULL && curr->right != NULL)
{
if(parent->left == curr)
{
parent->left = curr->right;
delete curr;
}
else
{
parent->right = curr->right;
delete curr;
}
}
else // left child present, no right child
{
if(parent->left == curr)
{
parent->left = curr->left;
delete curr;
}
else
{
parent->right = curr->left;
delete curr;
}
}
return;
}
//We\'re looking at a leaf node
if( curr->left == NULL && curr->right == NULL)
{
if(parent->left == curr) parent->left = NULL;
else parent->right = NULL;
delete curr;
return;
}
//Node with 2 children
// replace node with smallest value in right subtree
if (curr->left != NULL && curr->right != NULL)
{
tree_node* chkr;
chkr = curr->right;
if((chkr->left == NULL) && (chkr->right == NULL))
{
curr = chkr;
delete chkr;
curr->right = NULL;
}
else // right child has children
{
//if the node\'s right child has a left child
// Move all the way down left to locate smallest element
if((curr->right)->left != NULL)
{
tree_node* lcurr;
tree_node* lcurrp;
lcurrp = curr->right;
lcurr = (curr->right)->left;
while(lcurr->left != NULL)
{
lcurrp = lcurr;
lcurr = lcurr->left;
}
curr->data = lcurr->data;
delete lcurr;
lcurrp->left = NULL;
}
else
{
tree_node* tmp;
tmp = curr->right;
curr->data = tmp->data;
curr->right = tmp->right;
delete tmp;
}
}
return;
}
}
void BinarySearchTree::print_inorder()
{
inorder(root);
}
void BinarySearchTree::inorder(tree_node* p) .
Tree Traversals A tree traversal is the process of visiting.pdf
Tree Traversals
A tree traversal is the process of "visiting" each node of a tree in some particular order. For a
binary search tree, we can talk about an inorder traversal and a preorder traversal. For this
assignment you are to implement both of these traversals in the code that was started in class.
File bstree.h contains the BSTree class that was developed during class (with the addition of
comments which were omitted by your instructor due to time constraints). The class contains two
inorder functions, one public and one private, and two preorder functions, also one public and one
private. As was the case with other functions implemented for this class, the public versions of
these functions simply call the private versions passing the root node (pointer) as a parameter.
The private versions carry out their actions on the subtree rooted at the given node.
The code provided in bstree.h is missing the implementations for the private inorder and preorder
functions. The coding part of this assignment is to implement these two functions.
When completed, the test program provided should produce the following output:
Values stored in the tree are:
bird
cat
deer
dog
giraffe
groundhog
horse
snake
turtle
The structure of the tree is as follows:
dog
-bird
--cat
---deer
-turtle
--giraffe
---snake
----groundhog
-----horse
Copied!
Written Part
In addition to the coding noted above, give an analysis of all public member functions of the class,
including all constructors, the destructor, and the overload of the assignment operator. For your
analysis you may assume a well-balanced tree (whereas a lopsided tree might lead to a different
analysis).
bstree.h
#pragma once
// A Binary Search Tree implementation.
template <typename T>
class BSTree {
private:
// A node in the tree. Each node has pointers to its left and right nodes
// as well as its parent. When a node is created, the parent and data item
// must be provided.
class node {
public:
T data;
node* left;
node* right;
node* parent;
node (const T& d, node* p) {
parent = p;
data = d;
left = right = nullptr;
}
};
// Pointer to the root node. Initially this is null for an empty tree.
node* root;
// Copy the subtree of another BSTree object into this object. Used by
// the copy constructor and assignment operator.
void copy (node* p) {
if (p) { // If p points to a node...
insert(p->data); // Insert data item
copy(p->left); // Copy the left subtree
copy(p->right); // Copy the right subtree
}
}
// Destroy a node and all nodes in both subtrees. Called by the
// destructor.
void destroy (node* p) {
if (p) { // If p is not null...
destroy(p->left); // Destroy the left subtree
destroy(p->right); // Destroy the right subtree
delete p; // Destroy the node
}
}
// Helper function to determine if a data value is contained in the tree.
// Takes the data value being searched and a pointer to the node in the
// tree. Returns pointer to node in which data item is found, a null
// pointer otherwise.
node* find (const T& .
10 Solution#include-iostream-h- #include-conio-h- #include-process-h-.docx
10
Solution
#include<iostream.h>
#include<conio.h>
#include<process.h>
struct tree_node
{
tree_node *left;
tree_node *right;
int data;
} ;
class bst
{
tree_node *root;
public:
bst()
{
root=NULL;
}
int isempty()
{
return(root==NULL);
}
void insert(int item);
void inordertrav();
void inorder(tree_node *);
void postordertrav();
void postorder(tree_node *);
void preordertrav();
void preorder(tree_node *);
};
void bst::insert(int item)
{
tree_node *p=new tree_node;
tree_node *parent;
p->data=item;
p->left=NULL;
p->right=NULL;
parent=NULL;
if(isempty())
root=p;
else
{
tree_node *ptr;
ptr=root;
while(ptr!=NULL)
{
parent=ptr;
if(item>ptr->data)
ptr=ptr->right;
else
ptr=ptr->left;
}
if(item<parent->data)
parent->left=p;
else
parent->right=p;
}
}
void bst::inordertrav()
{
inorder(root);
}
void bst::inorder(tree_node *ptr)
{
if(ptr!=NULL)
{
inorder(ptr->left);
cout<<\" \"<<ptr->data<<\" \";
inorder(ptr->right);
}
}
void bst::postordertrav()
{
postorder(root);
}
void bst::postorder(tree_node *ptr)
{
if(ptr!=NULL)
{
postorder(ptr->left);
postorder(ptr->right);
cout<<\" \"<<ptr->data<<\" \";
}
}
void bst::preordertrav()
{
preorder(root);
}
void bst::preorder(tree_node *ptr)
{
if(ptr!=NULL)
{
cout<<\" \"<<ptr->data<<\" \";
preorder(ptr->left);
preorder(ptr->right);
}
}
void main()
{
bst b;
b.insert(52);
b.insert(25);
b.insert(50);
b.insert(15);
b.insert(40);
b.insert(45);
b.insert(20); cout<<\"inorder\"<<endl;
b.inordertrav();
cout<<endl<<\"postorder\"<<endl;
b.postordertrav();
cout<<endl<<\"preorder\"<<endl;
b.preordertrav();
getch();
}
.
Create a class BinarySearchTree- A class that implements the ADT binar.pdf
Create a class BinarySearchTree. A class that implements the ADT binary search tree by
extending BinaryTree. Recursive version.
public class BinarySearchTree<T extends Comparable<? super T>>
extends BinaryTree<T> implements SearchTreeInterface<T>
{
public BinarySearchTree ()
{
super();
} // end default constructor
public BinarySearchTree (T rootEntry)
{
super();
setRootNode(new BinaryNode<>(rootEntry));
} // end constructor
public void setTree (T rootData) // Disable setTree (see Segment 25.6)
{
throw new UnsupportedOperationException();
} // end setTree
public void setTree (T rootData, BinaryTreeInterface<T> leftTree, BinaryTreeInterface<T>
rightTree)
{
throw new UnsupportedOperationException();
} // end setTree
//...
public T remove (T entry)
{
ReturnObject oldEntry = new ReturnObject(null);
BinaryNode<T> newRoot = removeEntry(getRootNode(), entry, oldEntry);
setRootNode(newRoot);
return oldEntry.get();
} // end remove
//...
private class ReturnObject
{
private T item;
private ReturnObject(T entry)
{
item = entry;
} // end constructor
public T get()
{
return item;
} // end get
public void set(T entry)
{
item = entry;
} // end set
} // end ReturnObject
} // end BinarySearchTree
HERE IS BinaryTree.java
import java.util.Iterator;
import java.util.NoSuchElementException;
public class BinaryTree<T> implements BinaryTreeInterface<T> {
private BinaryNode<T> root;
public BinaryTree() {
root = null;
}
public BinaryTree(T rootData) {
root = new BinaryNode<>(rootData);
}
public BinaryTree(T rootData, BinaryTree<T> leftTree, BinaryTree<T> rightTree) {
privateSetTree(rootData, leftTree, rightTree);
}
private void privateSetTree(T rootData, BinaryTree<T> leftTree, BinaryTree<T>
rightTree) {
root = new BinaryNode<>(rootData);
if (leftTree != null && !leftTree.isEmpty()) {
root.setLeftChild(leftTree.root);
}
if (rightTree != null && !rightTree.isEmpty()) {
if (rightTree != leftTree) {
root.setRightChild(rightTree.root);
} else {
root.setRightChild(rightTree.root.copy());
}
}
if (leftTree != null && leftTree != this) {
leftTree.clear();
}
if (rightTree != null && rightTree != this) {
rightTree.clear();
}
}
@Override
public T getRootData() {
if (isEmpty()) {
throw new EmptyTreeException("The tree is empty.");
}
return root.getData();
}
@Override
public int getHeight() {
return root.getHeight();
}
@Override
public int getNumberOfNodes() {
return root.getNumberOfNodes();
}
@Override
public boolean isEmpty() {
return root == null;
}
@Override
public void clear() {
root = null;
}
@Override
public Iterator<T> getPreorderIterator() {
return new PreorderIterator();
}
@Override
public Iterator<T> getInorderIterator() {
return new InorderIterator();
}
@Override
public Iterator<T> getPostorderIterator() {
return new PostorderIterator();
}
private class PreorderIterator implements Iterator<T> {
private StackInterface<BinaryNode<T>> nodeStack;
public PreorderIterator() {
nodeStack = new LinkedStack<>();
if (root != null) {
nodeStack.push(root);
}
}
public boolean hasNex.
5. Design and implement a method contains 2 for BinarySearchTree, fu.pdf
5. Design and implement a method contains 2 for BinarySearchTree, functionall equivalent to
the contains method, that does not use recursion.
show the driver code and do this in java
this is the binarysearchtree
import java.util.*; // Iterator, Comparator
public class BinarySearchTree implements BSTInterface
{
protected BSTNode root; // reference to the root of this BST
protected Comparator comp; // used for all comparisons
protected boolean found; // used by remove
public BinarySearchTree()
// Precondition: T implements Comparable
// Creates an empty BST object - uses the natural order of elements.
{
root = null;
comp = new Comparator()
{
public int compare(T element1, T element2)
{
return ((Comparable)element1).compareTo(element2);
}
};
}
public BinarySearchTree(Comparator comp)
// Creates an empty BST object - uses Comparator comp for order
// of elements.
{
root = null;
this.comp = comp;
}
public boolean isFull()
// Returns false; this link-based BST is never full.
{
return false;
}
public boolean isEmpty()
// Returns true if this BST is empty; otherwise, returns false.
{
return (root == null);
}
public T min()
// If this BST is empty, returns null;
// otherwise returns the smallest element of the tree.
{
if (isEmpty())
return null;
else
{
BSTNode node = root;
while (node.getLeft() != null)
node = node.getLeft();
return node.getInfo();
}
}
public T max()
// If this BST is empty, returns null;
// otherwise returns the largest element of the tree.
{
if (isEmpty())
return null;
else
{
BSTNode node = root;
while (node.getRight() != null)
node = node.getRight();
return node.getInfo();
}
}
private int recSize(BSTNode node)
// Returns the number of elements in subtree rooted at node.
{
if (node == null)
return 0;
else
return 1 + recSize(node.getLeft()) + recSize(node.getRight());
}
public int size()
// Returns the number of elements in this BST.
{
return recSize(root);
}
public int size2()
// Returns the number of elements in this BST.
{
int count = 0;
if (root != null)
{
LinkedStack> nodeStack = new LinkedStack>();
BSTNode currNode;
nodeStack.push(root);
while (!nodeStack.isEmpty())
{
currNode = nodeStack.top();
nodeStack.pop();
count++;
if (currNode.getLeft() != null)
nodeStack.push(currNode.getLeft());
if (currNode.getRight() != null)
nodeStack.push(currNode.getRight());
}
}
return count;
}
private boolean recContains(T target, BSTNode node)
// Returns true if the subtree rooted at node contains info i such that
// comp.compare(target, i) == 0; otherwise, returns false.
{
if (node == null)
return false; // target is not found
else if (comp.compare(target, node.getInfo()) < 0)
return recContains(target, node.getLeft()); // Search left subtree
else if (comp.compare(target, node.getInfo()) > 0)
return recContains(target, node.getRight()); // Search right subtree
else
return true; // target is found
}
public boolean contains (T target)
// Returns true if this BST contains a node with info i such that
// comp.compare(target, i) == 0; otherwise, re.
Objective Binary Search Tree traversal (2 points)Use traversal.pp.pdf
Objective: Binary Search Tree traversal (2 points)
Use traversal.pptx as guidance to write a program to build a binary search tree Dictionary. Input
records from inventory.txt. Both key and Element of BST have the same data from each input
record.
public interface BinNode {
/** Get and set the element value */
public E element();
public void setElement(E v);
/** @return The left child */
public BinNode left();
/** @return The right child */
public BinNode right();
/** @return True if a leaf node, false otherwise */
public boolean isLeaf();
}
import java.lang.Comparable;
/** Binary Search Tree implementation for Dictionary ADT */
class BST, E>
implements Dictionary {
private BSTNode root; // Root of the BST
int nodecount; // Number of nodes in the BST
/** Constructor */
BST() { root = null; nodecount = 0; }
/** Reinitialize tree */
public void clear() { root = null; nodecount = 0; }
/** Insert a record into the tree.
@param k Key value of the record.
@param e The record to insert. */
public void insert(Key k, E e) {
root = inserthelp(root, k, e);
nodecount++;
}
// Return root
public BSTNode getRoot()
{
return root;
}
/** Remove a record from the tree.
@param k Key value of record to remove.
@return The record removed, null if there is none. */
public E remove(Key k) {
E temp = findhelp(root, k); // First find it
if (temp != null) {
root = removehelp(root, k); // Now remove it
nodecount--;
}
return temp;
}
/** Remove and return the root node from the dictionary.
@return The record removed, null if tree is empty. */
public E removeAny() {
if (root == null) return null;
E temp = root.element();
root = removehelp(root, root.key());
nodecount--;
return temp;
}
/** @return Record with key value k, null if none exist.
@param k The key value to find. */
public E find(Key k) { return findhelp(root, k); }
/** @return The number of records in the dictionary. */
public int size() { return nodecount; }
private E findhelp(BSTNode rt, Key k) {
if (rt == null) return null;
if (rt.key().compareTo(k) > 0)
return findhelp(rt.left(), k);
else if (rt.key().compareTo(k) == 0) return rt.element();
else return findhelp(rt.right(), k);
}
/** @return The current subtree, modified to contain
the new item */
private BSTNode inserthelp(BSTNode rt,
Key k, E e) {
if (rt == null) return new BSTNode(k, e);
if (rt.key().compareTo(k) > 0)
rt.setLeft(inserthelp(rt.left(), k, e));
else
rt.setRight(inserthelp(rt.right(), k, e));
return rt;
}
/** Remove a node with key value k
@return The tree with the node removed */
private BSTNode removehelp(BSTNode rt,Key k) {
if (rt == null) return null;
if (rt.key().compareTo(k) > 0)
rt.setLeft(removehelp(rt.left(), k));
else if (rt.key().compareTo(k) < 0)
rt.setRight(removehelp(rt.right(), k));
else { // Found it
if (rt.left() == null) return rt.right();
else if (rt.right() == null) return rt.left();
else { // Two children
BSTNode temp = getmin(rt.right());
rt.setElement(temp.element());
rt.setKey(temp.key());
rt.setRight(deletemin(rt.right(.
Write a function in C++ to generate an N-node random binary search t.pdf
Write a function in C++ to generate an N-node random binary search tree with distinct keys 1
through N.
Assume that you have available a function, randInt(lower,upper), that generates a uniform
random integer in the appropriate closed interval.
What is the running time of your routine?
Solution
/ A C++ prgroam to contrcut all unique BSTs for keys from 1 to n
#include
#include
using namespace std;
// node structure
struct node
{
int key;
struct node *left, *right;
};
// A utility function to create a new BST node
struct node *newNode(int item)
{
struct node *temp = new node;
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
// A utility function to do preorder traversal of BST
void preorder(struct node *root)
{
if (root != NULL)
{
cout << root->key << \" \";
preorder(root->left);
preorder(root->right);
}
}
// function for constructing trees
vector constructTrees(int start, int end)
{
vector list;
/* if start > end then subtree will be empty so returning NULL
in the list */
if (start > end)
{
list.push_back(NULL);
return list;
}
/* iterating through all values from start to end for constructing\\
left and right subtree recursively */
for (int i = start; i <= end; i++)
{
/* constructing left subtree */
vector leftSubtree = constructTrees(start, i - 1);
/* constructing right subtree */
vector rightSubtree = constructTrees(i + 1, end);
/* now looping through all left and right subtrees and connecting
them to ith root below */
for (int j = 0; j < leftSubtree.size(); j++)
{
struct node* left = leftSubtree[j];
for (int k = 0; k < rightSubtree.size(); k++)
{
struct node * right = rightSubtree[k];
struct node * node = newNode(i);// making value i as root
node->left = left; // connect left subtree
node->right = right; // connect right subtree
list.push_back(node); // add this tree to list
}
}
}
return list;
}
// Driver Program to test above functions
int main()
{
// Construct all possible BSTs
vector totalTreesFrom1toN = constructTrees(1, 3);
/* Printing preorder traversal of all constructed BSTs */
cout << \"Preorder traversals of all constructed BSTs are \ \";
for (int i = 0; i < totalTreesFrom1toN.size(); i++)
{
preorder(totalTreesFrom1toN[i]);
cout << endl;
}
return 0;
}
Output:.
A)B) C++ program to create a Complete Binary tree from its Lin.pdf
A)
B)
// C++ program to create a Complete Binary tree from its Linked List
// Representation
#include
#include
#include
using namespace std;
// Linked list node
struct ListNode
{
int data;
ListNode* next;
};
// Binary tree node structure
struct BinaryTreeNode
{
int data;
BinaryTreeNode *left, *right;
};
// Function to insert a node at the beginning of the Linked List
void push(struct ListNode** head_ref, int new_data)
{
// allocate node and assign data
struct ListNode* new_node = new ListNode;
new_node->data = new_data;
// link the old list off the new node
new_node->next = (*head_ref);
// move the head to point to the new node
(*head_ref) = new_node;
}
// method to create a new binary tree node from the given data
BinaryTreeNode* newBinaryTreeNode(int data)
{
BinaryTreeNode *temp = new BinaryTreeNode;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
// converts a given linked list representing a complete binary tree into the
// linked representation of binary tree.
void convertList2Binary(ListNode *head, BinaryTreeNode* &root)
{
// queue to store the parent nodes
queue q;
// Base Case
if (head == NULL)
{
root = NULL; // Note that root is passed by reference
return;
}
// 1.) The first node is always the root node, and add it to the queue
root = newBinaryTreeNode(head->data);
q.push(root);
// advance the pointer to the next node
head = head->next;
// until the end of linked list is reached, do the following steps
while (head)
{
// 2.a) take the parent node from the q and remove it from q
BinaryTreeNode* parent = q.front();
q.pop();
// 2.c) take next two nodes from the linked list. We will add
// them as children of the current parent node in step 2.b. Push them
// into the queue so that they will be parents to the future nodes
BinaryTreeNode *leftChild = NULL, *rightChild = NULL;
leftChild = newBinaryTreeNode(head->data);
q.push(leftChild);
head = head->next;
if (head)
{
rightChild = newBinaryTreeNode(head->data);
q.push(rightChild);
head = head->next;
}
// 2.b) assign the left and right children of parent
parent->left = leftChild;
parent->right = rightChild;
}
}
// Utility function to traverse the binary tree after conversion
void inorderTraversal(BinaryTreeNode* root)
{
if (root)
{
inorderTraversal( root->left );
cout << root->data << \" \";
inorderTraversal( root->right );
}
}
// Driver program to test above functions
int main()
{
// create a linked list shown in above diagram
struct ListNode* head = NULL;
push(&head, 36); /* Last node of Linked List */
push(&head, 30);
push(&head, 25);
push(&head, 15);
push(&head, 12);
push(&head, 10); /* First node of Linked List */
BinaryTreeNode *root;
convertList2Binary(head, root);
cout << \"Inorder Traversal of the constructed Binary Tree is: \ \";
inorderTraversal(root);
return 0;
}
c)
#include
#include
using namespace std;
template
class bintree
{
bintree *left;
T data;
bintree *right;
public :
bintree()
{
left=right=NULL;
}
void create();
void preorder();
void inorder();
void pos.
Data StructuresPlease I need help completing this c++ program..pdf
Data Structures
Please I need help completing this c++ program. it was giving to complete it with no other
discriptions.
#include
using namespace std;
template
struct node
{
datatype info;
node *left, *right;
};
template
class tree
{
public:
tree();
~tree();
bool isempty();
void inserttree(datatype data);
void print();
private:
node *root;
};
template
tree::tree()
{
root = NULL;
}
template
void tree ::inserttree(datatype data)
{
node *temp;
temp = new node ;
temp->left = NULL;
temp->right = NULL;
temp->info = data;
if (root == NULL)
root = temp;
else
before = NULL;
after = root;
while (after != NULL)
{
b = a;
root
...;
else
}
if(temp->info< before->info)
before->left = temp;
else
before->right = temp;
//before = after;
//if (temp->info < after->info)
//after = after->left;
//else
//after = after->right;
//if(temp->info< before->info)
//before->left = temp;
//else
//before->right = temp;
}
template
void tree ::print(tree *temp)
{
if (temp != NULL)
{
print(temp->left);
cout << temp->info << endl;
print(temp->right);
}
p();
print(root);
}
int main()
{
tree t;
//put this in a loop
t.inserttree(90);
t.inserttree(80);
t.inserttree(108);
t.p();
}
Solution
// HEADER FILE FOR BINARY TREE//
// Define a structure to be used as the tree node
struct TreeNode
{
int Key;
float fValue;
int iValue;
char cArray[7];
TreeNode *left;
TreeNode *right;
};
class Code202_Tree
{
private:
TreeNode *root;
public:
Code202_Tree();
~Code202_Tree();
bool isEmpty();
TreeNode *SearchTree(int Key);
bool Insert(TreeNode *newNode);
bool Insert(int Key, float f, int i, char *cA);
bool Delete(int Key);
void PrintOne(TreeNode *T);
void PrintTree();
private:
void ClearTree(TreeNode *T);
TreeNode *DupNode(TreeNode * T);
void PrintAll(TreeNode *T);
};
#endif
//IMPLEMENTATION .CPP FILE FOR BINARY TREE//
#include
#include
#include \"Code202_Tree.h\"
using namespace std;
//--------------------------------------------
// Function: Code202_Tree()
// Purpose: Class constructor.
//--------------------------------------------
Code202_Tree::Code202_Tree()
{
root = NULL;
return;
}
//--------------------------------------------
// Function: Code202_Tree()
// Purpose: Class destructor.
//--------------------------------------------
Code202_Tree::~Code202_Tree()
{
ClearTree(root);
return;
}
//--------------------------------------------
// Function: ClearTree()
// Purpose: Perform a recursive traversal of
// a tree destroying all nodes.
//--------------------------------------------
void Code202_Tree::ClearTree(TreeNode *T)
{
if(T==NULL) return; // Nothing to clear
if(T->left != NULL) ClearTree(T->left); // Clear left sub-tree
if(T->right != NULL) ClearTree(T->right); // Clear right sub-tree
delete T; // Destroy this node
return;
}
//--------------------------------------------
// Function: isEmpty()
// Purpose: Return TRUE if tree is empty.
//--------------------------------------------
bool Code202_Tree::isEmpty()
{
return(root==NULL);
}
//--------------------------------------------
// Function.
JavaCreate a java application using the code example in the follo.pdf
Java:
Create a java application using the code example in the following URL regarding a binary search
tree structure:
CODE EXAMPLE:
class BST_class {
//node class that defines BST node
class Node {
int key;
Node left, right;
public Node(int data){
key = data;
left = right = null;
}
}
// BST root node
Node root;
// Constructor for BST =>initial empty tree
BST_class(){
root = null;
}
//delete a node from BST
void deleteKey(int key) {
root = delete_Recursive(root, key);
}
//recursive delete function
Node delete_Recursive(Node root, int key) {
//tree is empty
if (root == null) return root;
//traverse the tree
if (key < root.key) //traverse left subtree
root.left = delete_Recursive(root.left, key);
else if (key > root.key) //traverse right subtree
root.right = delete_Recursive(root.right, key);
else {
// node contains only one child
if (root.left == null)
return root.right;
else if (root.right == null)
return root.left;
// node has two children;
//get inorder successor (min value in the right subtree)
root.key = minValue(root.right);
// Delete the inorder successor
root.right = delete_Recursive(root.right, root.key);
}
return root;
}
int minValue(Node root) {
//initially minval = root
int minval = root.key;
//find minval
while (root.left != null) {
minval = root.left.key;
root = root.left;
}
return minval;
}
// insert a node in BST
void insert(int key) {
root = insert_Recursive(root, key);
}
//recursive insert function
Node insert_Recursive(Node root, int key) {
//tree is empty
if (root == null) {
root = new Node(key);
return root;
}
//traverse the tree
if (key < root.key) //insert in the left subtree
root.left = insert_Recursive(root.left, key);
else if (key > root.key) //insert in the right subtree
root.right = insert_Recursive(root.right, key);
// return pointer
return root;
}
// method for inorder traversal of BST
void inorder() {
inorder_Recursive(root);
}
// recursively traverse the BST
void inorder_Recursive(Node root) {
if (root != null) {
inorder_Recursive(root.left);
System.out.print(root.key + " ");
inorder_Recursive(root.right);
}
}
boolean search(int key) {
root = search_Recursive(root, key);
if (root!= null)
return true;
else
return false;
}
//recursive insert function
Node search_Recursive(Node root, int key) {
// Base Cases: root is null or key is present at root
if (root==null || root.key==key)
return root;
// val is greater than root's key
if (root.key > key)
return search_Recursive(root.left, key);
// val is less than root's key
return search_Recursive(root.right, key);
}
}
class Main{
public static void main(String[] args) {
//create a BST object
BST_class bst = new BST_class();
/* BST tree example
45
/ \
10 90
/ \ /
7 12 50 */
//insert data into BST
bst.insert(45);
bst.insert(10);
bst.insert(7);
bst.insert(12);
bst.insert(90);
bst.insert(50);
//print the BST
System.out.println("The BST Created with input data(Left-root-right):");
bst.inorder();
//delete leaf node
System.out.println("\nThe BST after Delete 12(leaf node):");
bst.
Help to implement delete_node get_succ get_pred walk and.pdf
Help to implement delete_node, get_succ, get_pred, walk, and tree_search in the script
following the given structure:
#include "bst.h"
// ---------------------------------------
// Node class
// Default constructor
Node::Node() {
// TODO: Implement this
key = 0;
parent = nullptr;
left = nullptr;
right = nullptr;
}
// Constructor
Node::Node(int in) {
// TODO: Implement this
key = in;
parent = nullptr;
left = nullptr;
right = nullptr;
}
// Destructor
Node::~Node() {
// TODO: Implement this
delete left;
delete right;
}
// Add parent
void Node::add_parent(Node* in) {
// TODO: Implement this
parent = in;
}
// Add to left of current node
void Node::add_left(Node* in) {
// TODO: Implement this
left = in;
if (in != nullptr) {
in->add_parent(this);
}
}
// Add to right of current node
void Node::add_right(Node* in) {
// TODO: Implement this
right = in;
if (in != nullptr) {
in->add_parent(this);
}
}
// Get key
int Node::get_key()
{
// TODO: Implement this
return key;
}
// Get parent node
Node* Node::get_parent()
{
// TODO: Implement this
return parent;
}
// Get left node
Node* Node::get_left()
{
// TODO: Implement this
return left;
}
// Get right node
Node* Node::get_right()
{
// TODO: Implement this
return right;
}
// Print the key to ostream to
// Do not change this
void Node::print_info(ostream& to)
{
to << key << endl;
}
// ---------------------------------------
// ---------------------------------------
// BST class
// Walk the subtree from the given node
void BST::inorder_walk(Node* in, ostream& to)
{
// TODO: Implement this
if (in != nullptr) {
inorder_walk(in->get_left(), to);
in->print_info(to);
inorder_walk(in->get_right(), to);
}
}
// Constructor
BST::BST()
{
// TODO: Implement this
root = nullptr;
}
// Destructor
BST::~BST()
{
// TODO: Implement this
delete root;
}
// Insert a node to the subtree
void BST::insert_node(Node* in)
{
// TODO: Implement this
Node* curr = root;
Node* par = nullptr;
while (curr != nullptr) {
par = curr;
if (in->get_key() < curr->get_key()) {
curr = curr->get_left();
} else {
curr = curr->get_right();
}
}
in->add_parent(par);
if (par == nullptr) {
root = in;
} else if (in->get_key() < par->get_key()) {
par->add_left(in);
} else {
par->add_right(in);
}
}
// Delete a node to the subtree
void BST::delete_node(Node* out)
{
// TODO: Implement this
}
// minimum key in the BST
Node* BST::tree_min()
{
// TODO: Implement this
return get_min(root);
}
// maximum key in the BST
Node* BST::tree_max()
{
// TODO: Implement this
return get_max(root);
}
// Get the minimum node from the subtree of given node
Node* BST::get_min(Node* in)
{
// TODO: Implement this
if (in == nullptr) {
return nullptr;
}
while (in->get_left() != nullptr) {
in = in->get_left();
}
return in;
}
// Get the maximum node from the subtree of given node
Node* BST::get_max(Node* in)
{
// TODO: Implement this
if (in == nullptr) {
return nullptr;
}
while (in->get_right() != nullptr) {
in = in->get_right();
}
return in;
}
// Get successor of the given node
Node* BS.
In c++ format please, for each function in the code, using the comme.pdf
In c++ format please, for each function in the code, using the comments fill in the function to
write the whole program.
#include
#include
using namespace std;
template
class BST
{
private:
struct Node
{
bstdata data;
Node* left;
Node* right;
Node(bstdata newdata): data(newdata), left(NULL), right(NULL) {}
};
typedef struct Node* NodePtr;
NodePtr root;
/**Private helper functions*/
void insertHelper(NodePtr root, bstdata value);
//private helper function for insert
//recursively inserts a value into the BST
void destructorHelper(NodePtr root);
//private helper function for the destructor
//recursively frees the memory in the BST
void inOrderPrintHelper(NodePtr root);
//private helper function for inOrderPrint
//recursively prints tree values in order from smallest to largest
void preOrderPrintHelper(NodePtr root);
//private helper function for preOrderPrint
//recursively prints tree values in preorder
void postOrderPrintHelper(NodePtr root);
//private helper function for postOrderPrint
//recursively prints tree values in postorder
/**Public functions*/
public:
BST();
//Instantiates a new Binary Search Tree
//post: a new Binary Search Tree object
~BST();
//frees the memory of the BST object
//All memory has been deallocated
bool isEmpty();
//determines whether the Binary Search Tree is empty
void insert(bstdata value);
//inserts a new value into the Binary Search Tree
//post: a new value inserted into the Binary Search Tree
bstdata getRoot();
//returns the value stored at the root of the Binary Search Tree
//pre: the Binary Search Tree is not empty
void inOrderPrint();
//calls the inOrderPrintHelper function to print out the values
//stored in the Binary Search Tree
//If the tree is empty, prints nothing
void preOrderPrint();
//calls the preOrderPrintHelper function to print out the values
//stored in the Binary Search Tree
//If the tree is empty, prints nothing
void postOrderPrint();
//calls the postOrderPrintHelper function to print out the values
//stored in the Binary Search Tree
//If the tree is empty, prints nothing
};
Solution
Below code is completed with the function prototypes :
#include
#include
using namespace std;
template
class BST
{
private:
struct Node
{
bstdata data;
Node* left;
Node* right;
Node(bstdata newdata): data(newdata), left(NULL), right(NULL) {}
};
typedef struct Node* NodePtr;
NodePtr root;
/**Private helper functions*/
void insertHelper(NodePtr root, bstdata value){
if(root==NULL)
{
NodePtr *newnode=new node;
newnode->data=value;
root=newnode;
}
else{
if(valuedata)
insertHelper(value,root->left);
else
insertHelper(value,root->right);
}
}
//private helper function for insert
//recursively inserts a value into the BST
void destructorHelper(NodePtr root);
//private helper function for the destructor
//recursively frees the memory in the BST
void inOrderPrintHelper(NodePtr root){
if (root != NULL)
{
inorder(root->left);
cout<data<right);
}
}
//private helper function for inOrderPrint
//recursively prints tree values in .
import javautilQueue import javautilLinkedList import .pdf
import java.util.Queue;
import java.util.LinkedList;
import java.util.NoSuchElementException;
public class BinaryTree<T extends Comparable<T>> {
BTNode root;
public BinaryTree() {
root = null;
}
public BinaryTree(BTNode root) {
root = null;
}
public void purge(){
root = null;
}
public boolean isEmpty(){
return root == null;
}
public void insert(T key){
if (root == null) {
root = new BTNode(key);
return;
}
BTNode temp;
Queue<BTNode> q = new LinkedList<BTNode>();
q.add(root);
// Do level order traversal until we find the first empty left or right child.
while (!q.isEmpty()) {
temp = q.poll();
if (temp.left == null) {
temp.left = new BTNode(key);
break;
}
else
q.add(temp.left);
if (temp.right == null) {
temp.right = new BTNode(key);
break;
}
else
q.add(temp.right);
}
}
// delete by copying last node
public void deleteByCopying(T data){
if(root == null)
throw new UnsupportedOperationException("Tree is empty!");
else if(root.left == null && root.right == null){
if(root.data.equals(data))
root = null;
else
throw new NoSuchElementException(data + " not in the tree.");
return;
}
Queue<BTNode> queue = new LinkedList<BTNode>();
queue.add(root);
BTNode keyNode = null;
BTNode currentNode = null;
BTNode parentNode = root;
boolean found = false;
while(! queue.isEmpty()){
currentNode = queue.poll();
if(currentNode.data.equals(data)){
if(! found){
keyNode = currentNode;
found = true;
}
}
if(currentNode.left != null){
queue.add(currentNode.left);
parentNode = currentNode;
}
if(currentNode.right != null){
queue.add(currentNode.right);
parentNode = currentNode;
}
}
if(! found)
throw new NoSuchElementException(data + " not in tree.");
while(! queue.isEmpty()){
currentNode = queue.poll();
System.out.print(currentNode.data + " ");
if(currentNode.left != null){
queue.add(currentNode.left);
parentNode = currentNode;
}
if(currentNode.right != null){
queue.add(currentNode.right);
parentNode = currentNode;
}
}
keyNode.data = currentNode.data;
if(parentNode.left == currentNode)
parentNode.left = null;
else if(parentNode.right == currentNode)
parentNode.right = null;
}
public void levelOrderTraversal(){ // BreadthFirstTraversal
levelOrderTraversal(root);
}
// BreadthFirst Traversal
protected void levelOrderTraversal(BTNode root){
if(root == null)
return;
Queue<BTNode> queue = new LinkedList<BTNode>();
BTNode node = root;
queue.add(node);
while(! queue.isEmpty()){
node = queue.poll();
visit(node);
if(node.left != null)
queue.add(node.left);
if(node.right != null)
queue.add(node.right);
}
}
public void levelOrderTraversalByLevels(){
levelOrderTraversalByLevels(root);
}
protected void levelOrderTraversalByLevels(BTNode<T> root){
Queue q = new LinkedList();
int levelNodes = 0;
if(root==null)
return;
q.add(root);
while(!q.isEmpty()){
levelNodes = q.size();
while(levelNodes>0){
BTNode n = (BTNode)q.remove();
System.out.print(" " + n.data);
if(n.left!=null)
q.add(n.left);
if(n.right!=null)
q.add(n.right);
levelNodes--;
}
System.out.println("");
}
}
protected void visit(BTNode<T.
Required to augment the authors Binary Search Tree (BST) code to .docx
Required to augment the author's Binary Search Tree (BST) code to support these new operations. Method names below are merely suggestions. (The author’s class is attached separately in the file called “authordoc”. I just built a simple test tree in the author’s main method which can be used to test the various operations. )
1. AnyType nthElement(int n) -- returns the n-th element (starting from 1) of the in-order traversal of the BST.
2. int rank( AnyType x ) -- returns the "rank" of x. The rank of an element is its position (starting with 1) in an in-order traversal.
3. AnyType median( ) -- returns the median (middle) element in the BST. If the BST contains an even number of elements, returns the smaller of the two medians.
4. boolean isPerfect( ) -- returns true if the BST is a perfect binary tree.
5. boolean isComplete( ) -- returns true if the BST is a complete binary tree.
6. String toString( int nrLevels ) -- generates the level-order output described in the sample output below.
Most of these operations could easily be implemented by performing an in-order traversal inside the BST and perhaps placing the results in an ArrayList. However, such a method is extremely inefficient. Instead, we are going to achieve faster performance by "augmenting" the BST nodes. You will add a new private integer data member ("tree size") to the BinaryNode which stores the size of the tree rooted at that node (including the root). You must develop your own algorithms for these operations, but obviously you will use the new tree size data member to guide your search. Think before you code and think recursively!
These items cover those topics not addressed elsewhere in the project description. (R) indicates a requirement, (H) indicates a hint, and (N) indicates a note.
1. (R) Although we are only using the BST for integers, the BST must remain a generic class.
2. (R) Duplicate values are not allowed. Attempts to insert a duplicate value should be ignored.
3. (R) Attempts to remove non-existent values should be ignored.
4. (R) From a coding perspective, the easiest way to avoid duplicate insertions or attempting to remove non-existent elements is to first call find( ). However, this technique is NOT permitted for two reasons.
Calling find( ) before each insert/remove doubles the running time for these operations and is therefore inefficient.
Recusively coding the insert/remove methods to handle these situations is a great learning experience.
5. (R) The level order print (PRINT command) outputs the value of each node, the size of the tree rooted at that node, and the value of the node's parent in that order, inside parenthesis, separated by commas. (node value, tree size, parent value). Since the root has no parent, print NULL for the root's parent value. For readability, separate the levels with a blank line and print no more than 6 node/size/parent values per line. If a level requires multiple lines, use consecutive lines (without a blank line between the ...
Please finish everything marked TODO BinaryNode-java public class Bi.docx
Please finish everything marked TODO
BinaryNode.java
public class BinaryNode<E extends Comparable<E>> implements TreePrinter.PrintableNode{
private E data;
private BinaryNode<E> left;
private BinaryNode<E> right;
private int height;
private int size;
private BinaryNode<E> parent;
public BinaryNode(E data){
this.data = data;
this.left = null;
this.right = null;
this.parent = null;
this.height = 1;
this.size = 1;
}
// TODO: Set up the BinaryNode
public BinaryNode(E data, BinaryNode<E> left, BinaryNode<E> right, BinaryNode<E> parent){
}
// Access fields
E data() { return this.data; };
BinaryNode<E> left() {
return this.left;
}
BinaryNode<E> right() {
return this.right;
}
BinaryNode<E> parent() { return this.parent; }
// Setter fields
void setLeft(BinaryNode<E> left) {
this.left = left;
if(left != null) left.setParent(this);
}
void setRight(BinaryNode<E> right) {
this.right = right;
if(right != null) right.setParent(this);
}
void setParent(BinaryNode<E> parent) {
this.parent = parent;
}
void setData(E data) { this.data = data; }
void setHeight(int h){
this.height = h;
}
// Basic properties
int height() {
return this.height;
}
int size() { return this.size; }
boolean isBalanced() {
int leftHeight = (hasLeft()) ? left.height() : 0;
int rightHeight = (hasRight()) ? right().height() : 0;
return Math.abs(leftHeight - rightHeight) < 2;
}
boolean hasLeft(){
return left == null ? false : true;
}
boolean hasRight(){
return right == null ? false :true;
}
boolean hasParent(){
return parent == null ? false :true;
}
public boolean equals(BinaryNode<E> other){
if(other == null) return false;
return other.data.equals(this.data);
}
// Can use these to help debug
public TreePrinter.PrintableNode getLeft() {
return left == null ? null : left;
}
public TreePrinter.PrintableNode getRight() {
return right == null ? null : right;
}
public String getText() {
return String.valueOf(data);
}
public String toString(){
String ret = "";
return "root " + this.data + " Left: " +(hasLeft() ? left.data : null) + " Right: " +(hasRight() ? right.data : null) +
" parent: " + (hasParent() ? parent.data : null) ;
}
}
BST.java
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class BST<E extends Comparable<E>> implements Tree<E> {
private int height;
private int size;
private BinaryNode<E> root;
public BST(){
this.root = null;
this.height = 0;
this.size = 0;
}
// TODO: BST
public BST(BinaryNode<E> root){
}
// Access field
public BinaryNode<E> root() {
return this.root;
}
// Basic properties
public int height() {
return this.height;
}
public int size() {
return this.size;
}
public boolean isBalanced() {
return root.isBalanced();
}
// TODO: updateHeight - Update the root height to reflect any changes
public void updateHeight() {
}
// Traversals that return lists
// TODO: Preorder traversal
public List<E> preOrderList() {
return new ArrayList<>();
}
// .
public class Deque {private class Node {public int data;public.pdf
Given interval is `[0,2pi]` .
And given identity is `secx+tanx=1`
which we can write as `1/(cosx)+(sinx)/(cosx)=1`
`or` , `(1+sinx)/(cosx)=1`
or, `(1+sinx)=cosx`
or, `1+sinx-cosx=0`
or, `1+2sin(x/2)cos(x/2)-(1-2sin^2(x/2))=0`
or, `1+2sin(x/2)cos(x/2)-1+2sin^2(x/2)=0`
or, `2sin(x/2)cos(x/2)+2sin^2(x/2)=0`
or, `2sin(x/2)[cos(x/2)+sin(x/2)]=0`
`or,` `2sin(x/2)=0` and `cos(x/2)+sin(x/2)=0` .
Now, `2sin(x/2)=0` `rArrsin(x/2)=0` `rArrsin(x/2)=sin(npi)` , n=0,1,2. As per the need of our
problem.
`rArr x/2=npi` or, `x=2npi` for n=0,1 as our interval is `[0,2pi]` .
So, `x=0` or, `x=2pi` .
Now, if `cos(x/2)+sin(x/2)=0` `rArr1+(sin(x/2))/cos(x/2)=0`
`rArrtan(x/2)=-1` or, `tan(x/2)=tan(pi/2+pi/4)`
or, `x/2=(pi/2+pi/4)`
or, `x=pi+pi/2`
or, `x=3pi/2` .
Clearly, `x=0` and `x=2pi` are the solutions satisfying our given identity over the given interval.
Solution
Given interval is `[0,2pi]` .
And given identity is `secx+tanx=1`
which we can write as `1/(cosx)+(sinx)/(cosx)=1`
`or` , `(1+sinx)/(cosx)=1`
or, `(1+sinx)=cosx`
or, `1+sinx-cosx=0`
or, `1+2sin(x/2)cos(x/2)-(1-2sin^2(x/2))=0`
or, `1+2sin(x/2)cos(x/2)-1+2sin^2(x/2)=0`
or, `2sin(x/2)cos(x/2)+2sin^2(x/2)=0`
or, `2sin(x/2)[cos(x/2)+sin(x/2)]=0`
`or,` `2sin(x/2)=0` and `cos(x/2)+sin(x/2)=0` .
Now, `2sin(x/2)=0` `rArrsin(x/2)=0` `rArrsin(x/2)=sin(npi)` , n=0,1,2. As per the need of our
problem.
`rArr x/2=npi` or, `x=2npi` for n=0,1 as our interval is `[0,2pi]` .
So, `x=0` or, `x=2pi` .
Now, if `cos(x/2)+sin(x/2)=0` `rArr1+(sin(x/2))/cos(x/2)=0`
`rArrtan(x/2)=-1` or, `tan(x/2)=tan(pi/2+pi/4)`
or, `x/2=(pi/2+pi/4)`
or, `x=pi+pi/2`
or, `x=3pi/2` .
Clearly, `x=0` and `x=2pi` are the solutions satisfying our given identity over the given interval..
package lab7 public class SetOperations public static.pdf
package lab7;
public class SetOperations {
public static int[] makeSet(int[] data) {
if (data == null) {
return null;
}
int[] result = new int[data.length];
int index = 0;
boolean found;
for (int i = 0; i < data.length; i++) {
found = false;
for (int j = 0; j < index; j++) {
if (data[i] == result[j]) {
found = true;
break;
}
}
if (!found) {
result[index++] = data[i];
}
}
int[] finalResult = new int[index];
System.arraycopy(result, 0, finalResult, 0, index);
return finalResult;
}
public static boolean isSet(int[] data) {
if (data == null) {
return false;
}
for (int i = 0; i < data.length; i++) {
for (int j = i + 1; j < data.length; j++) {
if (data[i] == data[j]) {
return false;
}
}
}
return true;
}
public static int[] union(int[] setA, int[] setB) {
if (!isSet(setA) || !isSet(setB)) {
throw new IllegalArgumentException("One of the input arrays is not a set");
}
int[] result = new int[setA.length + setB.length];
int index = 0;
for (int i = 0; i < setA.length; i++) {
result[index++] = setA[i];
}
boolean found;
for (int i = 0; i < setB.length; i++) {
found = false;
for (int j = 0; j < setA.length; j++) {
if (setB[i] == setA[j]) {
found = true;
break;
}
}
if (!found) {
result[index++] = setB[i];
}
}
int[] finalResult = new int[index];
System.arraycopy(result, 0, finalResult, 0, index);
return finalResult;
}
public static int[] intersection(int[] setA, int[] setB) {
if (!isSet(setA) || !isSet(setB)) {
throw new IllegalArgumentException("One of the input arrays is not a set");
}
int[] smallerSet, largerSet;
if (setA.length < setB.length) {
smallerSet = setA;
largerSet = setB;
} else {
smallerSet = setB;
largerSet = setA;
}
int[] result = new int[smallerSet.length];
int index = 0;
for (int i = 0; i < smallerSet.length; i++) {
for (int j = 0; j < largerSet.length; j++) {
if (smallerSet[i] == largerSet[j]) {
result[index++] = smallerSet[i];
break;
}
}
}
int[] finalResult = new int[index];
System.arraycopy(result, 0, finalResult, 0, index);
return finalResult;
}
public static int[] difference(int[] setA, int[] setB) {
if (!isSet(setA) || !isSet(setB)) {
throw new IllegalArgumentException("One of the input arrays is not a set");
}
int[] diff = new int[setA.length];
int index = 0;
for (int i = 0; i < setA.length; i++) {
boolean found = false;
for (int j = 0; j < setB.length; j++) {
if (setA[i] == setB[j]) {
found = true;
break;
}
}
if (!found) {
diff[index++] = setA[i];
}
}
int[] result = new int[index];
System.arraycopy(diff, 0, result, 0, index);
return result;
}
}
Lab 7: Set Operations with Arrays Grading and Submission You are to write a complete Java
program that meets the requirements outlined in the Lab 7 Tasks section. Push your code to
GitHub in the same way you've pushed previous Labs: - Your code should be in a class named
"SetOperations.java" and in a package named "lab7" - So, the path to your code should be:
"Labs/Lab07/src/lab7/SetOperations.java" There will be 6 points for this lab, broken down in the
following way: 1. makeSet is implement.
How to do the main method for this programBinaryNode.javapublic.pdf
How to do the main method for this program?
BinaryNode.java
public class BinaryNode
implements Parent{
/** The item associated with this node. */
private E item;
/** The node at the root of the left subtree. */
private BinaryNode left;
/** The node at the root of the right subtree. */
private BinaryNode right;
/** Put item in a leaf node. */
public BinaryNode(E item) {
this.item = item;
// left and right are set to null by default
}
/** no-argument constructor sets everything to null */
public BinaryNode() {
item = null;
left = null;
right = null;
}
/** Put item in a node with the specified subtrees. */
public BinaryNode(E item, BinaryNode left,
BinaryNode right) {
this.item = item;
this.left = left;
this.right = right;
}
/** Put item in a node with the specified subtrees. */
public BinaryNode getChild(int direction) {
if (direction < 0) {
return left;
} else {
return right;
}
}
/** Return the item associated with this node. */
public E getItem() {
return item;
}
/** Return the root of the left subtree. */
public BinaryNode getLeft() {
return left;
}
/** Return the root of the right subtree. */
public BinaryNode getRight() {
return right;
}
/** Return true if this is a leaf. */
public boolean isLeaf() {
return (left == null) && (right == null);
}
/** Replace the item associated with this node. */
public void setItem(E item) {
this.item = item;
}
/** Replace the left subtree with the one rooted at left. */
public void setLeft(BinaryNode left) {
this.left = left;
}
/** Replace the right subtree with the one rooted at right. */
public void setRight(BinaryNode right) {
this.right = right;
}
public void setChild(int direction, BinaryNode child) {
if (direction < 0) {
left = child;
} else {
right = child;
}
}
/**
* Return the String representation of the tree rooted at this node
* traversed preorder.
**/
public String toStringPreorder() {
String result = \"\";
result += item;
if (left != null) {
result += left.toStringPreorder();
}
if (right != null) {
result += right.toStringPreorder();
}
return result;
}
/** Return a String representation of the tree rooted at this node
* traversed inorder.
**/
public String toStringInOrder() {
String result = \"\";
if (left != null) {
result += left.toStringInOrder();
}
result += item;
if (right != null) {
result += right.toStringInOrder();
}
return result;
}
/** Return a String representation of the tree rooted at this node,
* traversed postorder.
**/
public String toStringPostorder() {
String result = \"\";
if (left != null) {
result += left.toStringPostorder();
}
if (right != null) {
result += right.toStringPostorder();
}
result += item;
return result;
}
/**
* Return a String representation of the tree rooted at this node,
* traversed level order.
**/
public String toStringLevelOrder() {
String result = \"\";
Queue> q = new ArrayQueue>();
q.add (this);
while (!(q.isEmpty())) {
BinaryNode node = q.remove ();
result += node.item;
if (node.left != null) {
q.add(node.left);
}
if (node.right != null) {
q.add(node..
1)(JAVA) Extend the Binary Search Tree ADT to include a public metho.pdf
1)(JAVA) Extend the Binary Search Tree ADT to include a public method leafCount that returns
the number of leaf nodes in the tree.
Thank You in Advanced.
Below, I also have attached the BinarySearchTree and the Interface File.
BinarySearchTree:
//----------------------------------------------------------------------------
// BinarySearchTree.java by Dale/Joyce/Weems Chapter 8
//
// Defines all constructs for a reference-based BST
//----------------------------------------------------------------------------
package ch08.trees;
import ch05.queues.*;
import ch03.stacks.*;
import support.BSTNode;
public class BinarySearchTree>
implements BSTInterface
{
protected BSTNode root; // reference to the root of this BST
boolean found; // used by remove
// for traversals
protected LinkedUnbndQueue inOrderQueue; // queue of info
protected LinkedUnbndQueue preOrderQueue; // queue of info
protected LinkedUnbndQueue postOrderQueue; // queue of info
public BinarySearchTree()
// Creates an empty BST object.
{
root = null;
}
public boolean isEmpty()
// Returns true if this BST is empty; otherwise, returns false.
{
return (root == null);
}
private int recSize(BSTNode tree)
// Returns the number of elements in tree.
{
if (tree == null)
return 0;
else
return recSize(tree.getLeft()) + recSize(tree.getRight()) + 1;
}
public int size()
// Returns the number of elements in this BST.
{
return recSize(root);
}
public int size2()
// Returns the number of elements in this BST.
{
int count = 0;
if (root != null)
{
LinkedStack> hold = new LinkedStack>();
BSTNode currNode;
hold.push(root);
while (!hold.isEmpty())
{
currNode = hold.top();
hold.pop();
count++;
if (currNode.getLeft() != null)
hold.push(currNode.getLeft());
if (currNode.getRight() != null)
hold.push(currNode.getRight());
}
}
return count;
}
private boolean recContains(T element, BSTNode tree)
// Returns true if tree contains an element e such that
// e.compareTo(element) == 0; otherwise, returns false.
{
if (tree == null)
return false; // element is not found
else if (element.compareTo(tree.getInfo()) < 0)
return recContains(element, tree.getLeft()); // Search left subtree
else if (element.compareTo(tree.getInfo()) > 0)
return recContains(element, tree.getRight()); // Search right subtree
else
return true; // element is found
}
public boolean contains (T element)
// Returns true if this BST contains an element e such that
// e.compareTo(element) == 0; otherwise, returns false.
{
return recContains(element, root);
}
private T recGet(T element, BSTNode tree)
// Returns an element e from tree such that e.compareTo(element) == 0;
// if no such element exists, returns null.
{
if (tree == null)
return null; // element is not found
else if (element.compareTo(tree.getInfo()) < 0)
return recGet(element, tree.getLeft()); // get from left subtree
else
if (element.compareTo(tree.getInfo()) > 0)
return recGet(element, tree.getRight()); // get from right subtree
else
return tree.getInfo(); // element is found
}
public T get(T.
In 1998, Congress passed legislation concerning shifting the burden .pdf
In 1998, Congress passed legislation concerning shifting the burden of proof to the IRS. The
taxpayer must introduce \"credible evidence\" to shift the burden of proof to the IRS. What
constitutes \"credible evidence?\"
Solution
Credible evidence is not evidence which is necessarily true, but is evidence worthy of belief, that
is, worthy to be considered by the jury. It is often natural, reasonable and probable as to make it
easy to believe.
Pursuant to 89 Ill. (Adm. Code 300.20), \"Credible evidence of child abuse or neglect\" means
that the available facts, when viewed in light of surrounding circumstances, would cause a
reasonable person to believe that a child was abused or neglected.”
The 1998 tax law has provided that the burden of proof in tax court cases will be on the
government, not the taxpayer. However, it also provides that this can be shifted back to the
taxpayer in a number of circumstances, mostly involving lack of taxpayer cooperation with
examinations. The issue of who bears the burden of proof is important, even if your case, like
most, never goes as far as the tax court. This is because the burden will operate as a background
issue that will tend to help to affect the settlement posture of both the taxpayer and the IRS.
The burden of production, also known as the burden of going forward, is the burden of providing
sufficient evidence on an issue in order to prevail in the dispute. In Tax Court cases initiated by
the IRS, the government bears the burden of production. IRS is internal reserve service.
In order to avoid a shift-back in the burden of proof, the taxpayer must meet his burden of
production. That is, the
taxpayer must meet his record-keeping, substantiation, and cooperation requirements.
Conclusion:
The Restructuring and Reform Act of 1998 allows for the shift of the burden of proof from
taxpayers to the government, and generally serves to protect the interests of taxpayers who are
being audited by the IRS. This policy change benefits taxpayers, who previously had been
saddled with the burden of proof in almost all civil tax matters. Taxpayers must provide
substantial and credible evidence, meet record-keeping and substantiation requirements, and
cooperate with the IRS. The burden of proof oftentimes does not shift to the IRS because the
taxpayer feels to meet one of these important provisions. For this reason, the IRS Restructuring
and Reform Act of 1998 does not always provide taxpayers much relief from the previous
system. From a practical standpoint, meticulous and accurate record-keeping is of the most
important so that the taxpayer may be able to shift the burden of proof to IRS..
If A denotes some event, what does A denote If P(A)equals=0.997, wh.pdf
If A denotes some event, what does A denote? If P(A)equals=0.997, what is the value of P(A)? If
P(A)equals=0.997, is A unusual?
Solution
Sol)
P(not A)=0.003 (1-0.997=0.003) P(not A) , meaning that compliment of A consists of all
outcomes(results) in which event A does not occur. It is not unusual(only outcomes <0.05 are
unusual)..
More Related Content
Similar to To create a node for a binary search tree (BTNode, ) and to create a .pdf
Tree Traversals A tree traversal is the process of visiting.pdf
Tree Traversals
A tree traversal is the process of "visiting" each node of a tree in some particular order. For a
binary search tree, we can talk about an inorder traversal and a preorder traversal. For this
assignment you are to implement both of these traversals in the code that was started in class.
File bstree.h contains the BSTree class that was developed during class (with the addition of
comments which were omitted by your instructor due to time constraints). The class contains two
inorder functions, one public and one private, and two preorder functions, also one public and one
private. As was the case with other functions implemented for this class, the public versions of
these functions simply call the private versions passing the root node (pointer) as a parameter.
The private versions carry out their actions on the subtree rooted at the given node.
The code provided in bstree.h is missing the implementations for the private inorder and preorder
functions. The coding part of this assignment is to implement these two functions.
When completed, the test program provided should produce the following output:
Values stored in the tree are:
bird
cat
deer
dog
giraffe
groundhog
horse
snake
turtle
The structure of the tree is as follows:
dog
-bird
--cat
---deer
-turtle
--giraffe
---snake
----groundhog
-----horse
Copied!
Written Part
In addition to the coding noted above, give an analysis of all public member functions of the class,
including all constructors, the destructor, and the overload of the assignment operator. For your
analysis you may assume a well-balanced tree (whereas a lopsided tree might lead to a different
analysis).
bstree.h
#pragma once
// A Binary Search Tree implementation.
template <typename T>
class BSTree {
private:
// A node in the tree. Each node has pointers to its left and right nodes
// as well as its parent. When a node is created, the parent and data item
// must be provided.
class node {
public:
T data;
node* left;
node* right;
node* parent;
node (const T& d, node* p) {
parent = p;
data = d;
left = right = nullptr;
}
};
// Pointer to the root node. Initially this is null for an empty tree.
node* root;
// Copy the subtree of another BSTree object into this object. Used by
// the copy constructor and assignment operator.
void copy (node* p) {
if (p) { // If p points to a node...
insert(p->data); // Insert data item
copy(p->left); // Copy the left subtree
copy(p->right); // Copy the right subtree
}
}
// Destroy a node and all nodes in both subtrees. Called by the
// destructor.
void destroy (node* p) {
if (p) { // If p is not null...
destroy(p->left); // Destroy the left subtree
destroy(p->right); // Destroy the right subtree
delete p; // Destroy the node
}
}
// Helper function to determine if a data value is contained in the tree.
// Takes the data value being searched and a pointer to the node in the
// tree. Returns pointer to node in which data item is found, a null
// pointer otherwise.
node* find (const T& .
10 Solution#include-iostream-h- #include-conio-h- #include-process-h-.docx
10
Solution
#include<iostream.h>
#include<conio.h>
#include<process.h>
struct tree_node
{
tree_node *left;
tree_node *right;
int data;
} ;
class bst
{
tree_node *root;
public:
bst()
{
root=NULL;
}
int isempty()
{
return(root==NULL);
}
void insert(int item);
void inordertrav();
void inorder(tree_node *);
void postordertrav();
void postorder(tree_node *);
void preordertrav();
void preorder(tree_node *);
};
void bst::insert(int item)
{
tree_node *p=new tree_node;
tree_node *parent;
p->data=item;
p->left=NULL;
p->right=NULL;
parent=NULL;
if(isempty())
root=p;
else
{
tree_node *ptr;
ptr=root;
while(ptr!=NULL)
{
parent=ptr;
if(item>ptr->data)
ptr=ptr->right;
else
ptr=ptr->left;
}
if(item<parent->data)
parent->left=p;
else
parent->right=p;
}
}
void bst::inordertrav()
{
inorder(root);
}
void bst::inorder(tree_node *ptr)
{
if(ptr!=NULL)
{
inorder(ptr->left);
cout<<\" \"<<ptr->data<<\" \";
inorder(ptr->right);
}
}
void bst::postordertrav()
{
postorder(root);
}
void bst::postorder(tree_node *ptr)
{
if(ptr!=NULL)
{
postorder(ptr->left);
postorder(ptr->right);
cout<<\" \"<<ptr->data<<\" \";
}
}
void bst::preordertrav()
{
preorder(root);
}
void bst::preorder(tree_node *ptr)
{
if(ptr!=NULL)
{
cout<<\" \"<<ptr->data<<\" \";
preorder(ptr->left);
preorder(ptr->right);
}
}
void main()
{
bst b;
b.insert(52);
b.insert(25);
b.insert(50);
b.insert(15);
b.insert(40);
b.insert(45);
b.insert(20); cout<<\"inorder\"<<endl;
b.inordertrav();
cout<<endl<<\"postorder\"<<endl;
b.postordertrav();
cout<<endl<<\"preorder\"<<endl;
b.preordertrav();
getch();
}
.
Create a class BinarySearchTree- A class that implements the ADT binar.pdf
Create a class BinarySearchTree. A class that implements the ADT binary search tree by
extending BinaryTree. Recursive version.
public class BinarySearchTree<T extends Comparable<? super T>>
extends BinaryTree<T> implements SearchTreeInterface<T>
{
public BinarySearchTree ()
{
super();
} // end default constructor
public BinarySearchTree (T rootEntry)
{
super();
setRootNode(new BinaryNode<>(rootEntry));
} // end constructor
public void setTree (T rootData) // Disable setTree (see Segment 25.6)
{
throw new UnsupportedOperationException();
} // end setTree
public void setTree (T rootData, BinaryTreeInterface<T> leftTree, BinaryTreeInterface<T>
rightTree)
{
throw new UnsupportedOperationException();
} // end setTree
//...
public T remove (T entry)
{
ReturnObject oldEntry = new ReturnObject(null);
BinaryNode<T> newRoot = removeEntry(getRootNode(), entry, oldEntry);
setRootNode(newRoot);
return oldEntry.get();
} // end remove
//...
private class ReturnObject
{
private T item;
private ReturnObject(T entry)
{
item = entry;
} // end constructor
public T get()
{
return item;
} // end get
public void set(T entry)
{
item = entry;
} // end set
} // end ReturnObject
} // end BinarySearchTree
HERE IS BinaryTree.java
import java.util.Iterator;
import java.util.NoSuchElementException;
public class BinaryTree<T> implements BinaryTreeInterface<T> {
private BinaryNode<T> root;
public BinaryTree() {
root = null;
}
public BinaryTree(T rootData) {
root = new BinaryNode<>(rootData);
}
public BinaryTree(T rootData, BinaryTree<T> leftTree, BinaryTree<T> rightTree) {
privateSetTree(rootData, leftTree, rightTree);
}
private void privateSetTree(T rootData, BinaryTree<T> leftTree, BinaryTree<T>
rightTree) {
root = new BinaryNode<>(rootData);
if (leftTree != null && !leftTree.isEmpty()) {
root.setLeftChild(leftTree.root);
}
if (rightTree != null && !rightTree.isEmpty()) {
if (rightTree != leftTree) {
root.setRightChild(rightTree.root);
} else {
root.setRightChild(rightTree.root.copy());
}
}
if (leftTree != null && leftTree != this) {
leftTree.clear();
}
if (rightTree != null && rightTree != this) {
rightTree.clear();
}
}
@Override
public T getRootData() {
if (isEmpty()) {
throw new EmptyTreeException("The tree is empty.");
}
return root.getData();
}
@Override
public int getHeight() {
return root.getHeight();
}
@Override
public int getNumberOfNodes() {
return root.getNumberOfNodes();
}
@Override
public boolean isEmpty() {
return root == null;
}
@Override
public void clear() {
root = null;
}
@Override
public Iterator<T> getPreorderIterator() {
return new PreorderIterator();
}
@Override
public Iterator<T> getInorderIterator() {
return new InorderIterator();
}
@Override
public Iterator<T> getPostorderIterator() {
return new PostorderIterator();
}
private class PreorderIterator implements Iterator<T> {
private StackInterface<BinaryNode<T>> nodeStack;
public PreorderIterator() {
nodeStack = new LinkedStack<>();
if (root != null) {
nodeStack.push(root);
}
}
public boolean hasNex.
5. Design and implement a method contains 2 for BinarySearchTree, fu.pdf
5. Design and implement a method contains 2 for BinarySearchTree, functionall equivalent to
the contains method, that does not use recursion.
show the driver code and do this in java
this is the binarysearchtree
import java.util.*; // Iterator, Comparator
public class BinarySearchTree implements BSTInterface
{
protected BSTNode root; // reference to the root of this BST
protected Comparator comp; // used for all comparisons
protected boolean found; // used by remove
public BinarySearchTree()
// Precondition: T implements Comparable
// Creates an empty BST object - uses the natural order of elements.
{
root = null;
comp = new Comparator()
{
public int compare(T element1, T element2)
{
return ((Comparable)element1).compareTo(element2);
}
};
}
public BinarySearchTree(Comparator comp)
// Creates an empty BST object - uses Comparator comp for order
// of elements.
{
root = null;
this.comp = comp;
}
public boolean isFull()
// Returns false; this link-based BST is never full.
{
return false;
}
public boolean isEmpty()
// Returns true if this BST is empty; otherwise, returns false.
{
return (root == null);
}
public T min()
// If this BST is empty, returns null;
// otherwise returns the smallest element of the tree.
{
if (isEmpty())
return null;
else
{
BSTNode node = root;
while (node.getLeft() != null)
node = node.getLeft();
return node.getInfo();
}
}
public T max()
// If this BST is empty, returns null;
// otherwise returns the largest element of the tree.
{
if (isEmpty())
return null;
else
{
BSTNode node = root;
while (node.getRight() != null)
node = node.getRight();
return node.getInfo();
}
}
private int recSize(BSTNode node)
// Returns the number of elements in subtree rooted at node.
{
if (node == null)
return 0;
else
return 1 + recSize(node.getLeft()) + recSize(node.getRight());
}
public int size()
// Returns the number of elements in this BST.
{
return recSize(root);
}
public int size2()
// Returns the number of elements in this BST.
{
int count = 0;
if (root != null)
{
LinkedStack> nodeStack = new LinkedStack>();
BSTNode currNode;
nodeStack.push(root);
while (!nodeStack.isEmpty())
{
currNode = nodeStack.top();
nodeStack.pop();
count++;
if (currNode.getLeft() != null)
nodeStack.push(currNode.getLeft());
if (currNode.getRight() != null)
nodeStack.push(currNode.getRight());
}
}
return count;
}
private boolean recContains(T target, BSTNode node)
// Returns true if the subtree rooted at node contains info i such that
// comp.compare(target, i) == 0; otherwise, returns false.
{
if (node == null)
return false; // target is not found
else if (comp.compare(target, node.getInfo()) < 0)
return recContains(target, node.getLeft()); // Search left subtree
else if (comp.compare(target, node.getInfo()) > 0)
return recContains(target, node.getRight()); // Search right subtree
else
return true; // target is found
}
public boolean contains (T target)
// Returns true if this BST contains a node with info i such that
// comp.compare(target, i) == 0; otherwise, re.
Objective Binary Search Tree traversal (2 points)Use traversal.pp.pdf
Objective: Binary Search Tree traversal (2 points)
Use traversal.pptx as guidance to write a program to build a binary search tree Dictionary. Input
records from inventory.txt. Both key and Element of BST have the same data from each input
record.
public interface BinNode {
/** Get and set the element value */
public E element();
public void setElement(E v);
/** @return The left child */
public BinNode left();
/** @return The right child */
public BinNode right();
/** @return True if a leaf node, false otherwise */
public boolean isLeaf();
}
import java.lang.Comparable;
/** Binary Search Tree implementation for Dictionary ADT */
class BST, E>
implements Dictionary {
private BSTNode root; // Root of the BST
int nodecount; // Number of nodes in the BST
/** Constructor */
BST() { root = null; nodecount = 0; }
/** Reinitialize tree */
public void clear() { root = null; nodecount = 0; }
/** Insert a record into the tree.
@param k Key value of the record.
@param e The record to insert. */
public void insert(Key k, E e) {
root = inserthelp(root, k, e);
nodecount++;
}
// Return root
public BSTNode getRoot()
{
return root;
}
/** Remove a record from the tree.
@param k Key value of record to remove.
@return The record removed, null if there is none. */
public E remove(Key k) {
E temp = findhelp(root, k); // First find it
if (temp != null) {
root = removehelp(root, k); // Now remove it
nodecount--;
}
return temp;
}
/** Remove and return the root node from the dictionary.
@return The record removed, null if tree is empty. */
public E removeAny() {
if (root == null) return null;
E temp = root.element();
root = removehelp(root, root.key());
nodecount--;
return temp;
}
/** @return Record with key value k, null if none exist.
@param k The key value to find. */
public E find(Key k) { return findhelp(root, k); }
/** @return The number of records in the dictionary. */
public int size() { return nodecount; }
private E findhelp(BSTNode rt, Key k) {
if (rt == null) return null;
if (rt.key().compareTo(k) > 0)
return findhelp(rt.left(), k);
else if (rt.key().compareTo(k) == 0) return rt.element();
else return findhelp(rt.right(), k);
}
/** @return The current subtree, modified to contain
the new item */
private BSTNode inserthelp(BSTNode rt,
Key k, E e) {
if (rt == null) return new BSTNode(k, e);
if (rt.key().compareTo(k) > 0)
rt.setLeft(inserthelp(rt.left(), k, e));
else
rt.setRight(inserthelp(rt.right(), k, e));
return rt;
}
/** Remove a node with key value k
@return The tree with the node removed */
private BSTNode removehelp(BSTNode rt,Key k) {
if (rt == null) return null;
if (rt.key().compareTo(k) > 0)
rt.setLeft(removehelp(rt.left(), k));
else if (rt.key().compareTo(k) < 0)
rt.setRight(removehelp(rt.right(), k));
else { // Found it
if (rt.left() == null) return rt.right();
else if (rt.right() == null) return rt.left();
else { // Two children
BSTNode temp = getmin(rt.right());
rt.setElement(temp.element());
rt.setKey(temp.key());
rt.setRight(deletemin(rt.right(.
Write a function in C++ to generate an N-node random binary search t.pdf
Write a function in C++ to generate an N-node random binary search tree with distinct keys 1
through N.
Assume that you have available a function, randInt(lower,upper), that generates a uniform
random integer in the appropriate closed interval.
What is the running time of your routine?
Solution
/ A C++ prgroam to contrcut all unique BSTs for keys from 1 to n
#include
#include
using namespace std;
// node structure
struct node
{
int key;
struct node *left, *right;
};
// A utility function to create a new BST node
struct node *newNode(int item)
{
struct node *temp = new node;
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
// A utility function to do preorder traversal of BST
void preorder(struct node *root)
{
if (root != NULL)
{
cout << root->key << \" \";
preorder(root->left);
preorder(root->right);
}
}
// function for constructing trees
vector constructTrees(int start, int end)
{
vector list;
/* if start > end then subtree will be empty so returning NULL
in the list */
if (start > end)
{
list.push_back(NULL);
return list;
}
/* iterating through all values from start to end for constructing\\
left and right subtree recursively */
for (int i = start; i <= end; i++)
{
/* constructing left subtree */
vector leftSubtree = constructTrees(start, i - 1);
/* constructing right subtree */
vector rightSubtree = constructTrees(i + 1, end);
/* now looping through all left and right subtrees and connecting
them to ith root below */
for (int j = 0; j < leftSubtree.size(); j++)
{
struct node* left = leftSubtree[j];
for (int k = 0; k < rightSubtree.size(); k++)
{
struct node * right = rightSubtree[k];
struct node * node = newNode(i);// making value i as root
node->left = left; // connect left subtree
node->right = right; // connect right subtree
list.push_back(node); // add this tree to list
}
}
}
return list;
}
// Driver Program to test above functions
int main()
{
// Construct all possible BSTs
vector totalTreesFrom1toN = constructTrees(1, 3);
/* Printing preorder traversal of all constructed BSTs */
cout << \"Preorder traversals of all constructed BSTs are \ \";
for (int i = 0; i < totalTreesFrom1toN.size(); i++)
{
preorder(totalTreesFrom1toN[i]);
cout << endl;
}
return 0;
}
Output:.
A)B) C++ program to create a Complete Binary tree from its Lin.pdf
A)
B)
// C++ program to create a Complete Binary tree from its Linked List
// Representation
#include
#include
#include
using namespace std;
// Linked list node
struct ListNode
{
int data;
ListNode* next;
};
// Binary tree node structure
struct BinaryTreeNode
{
int data;
BinaryTreeNode *left, *right;
};
// Function to insert a node at the beginning of the Linked List
void push(struct ListNode** head_ref, int new_data)
{
// allocate node and assign data
struct ListNode* new_node = new ListNode;
new_node->data = new_data;
// link the old list off the new node
new_node->next = (*head_ref);
// move the head to point to the new node
(*head_ref) = new_node;
}
// method to create a new binary tree node from the given data
BinaryTreeNode* newBinaryTreeNode(int data)
{
BinaryTreeNode *temp = new BinaryTreeNode;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
// converts a given linked list representing a complete binary tree into the
// linked representation of binary tree.
void convertList2Binary(ListNode *head, BinaryTreeNode* &root)
{
// queue to store the parent nodes
queue q;
// Base Case
if (head == NULL)
{
root = NULL; // Note that root is passed by reference
return;
}
// 1.) The first node is always the root node, and add it to the queue
root = newBinaryTreeNode(head->data);
q.push(root);
// advance the pointer to the next node
head = head->next;
// until the end of linked list is reached, do the following steps
while (head)
{
// 2.a) take the parent node from the q and remove it from q
BinaryTreeNode* parent = q.front();
q.pop();
// 2.c) take next two nodes from the linked list. We will add
// them as children of the current parent node in step 2.b. Push them
// into the queue so that they will be parents to the future nodes
BinaryTreeNode *leftChild = NULL, *rightChild = NULL;
leftChild = newBinaryTreeNode(head->data);
q.push(leftChild);
head = head->next;
if (head)
{
rightChild = newBinaryTreeNode(head->data);
q.push(rightChild);
head = head->next;
}
// 2.b) assign the left and right children of parent
parent->left = leftChild;
parent->right = rightChild;
}
}
// Utility function to traverse the binary tree after conversion
void inorderTraversal(BinaryTreeNode* root)
{
if (root)
{
inorderTraversal( root->left );
cout << root->data << \" \";
inorderTraversal( root->right );
}
}
// Driver program to test above functions
int main()
{
// create a linked list shown in above diagram
struct ListNode* head = NULL;
push(&head, 36); /* Last node of Linked List */
push(&head, 30);
push(&head, 25);
push(&head, 15);
push(&head, 12);
push(&head, 10); /* First node of Linked List */
BinaryTreeNode *root;
convertList2Binary(head, root);
cout << \"Inorder Traversal of the constructed Binary Tree is: \ \";
inorderTraversal(root);
return 0;
}
c)
#include
#include
using namespace std;
template
class bintree
{
bintree *left;
T data;
bintree *right;
public :
bintree()
{
left=right=NULL;
}
void create();
void preorder();
void inorder();
void pos.
Data StructuresPlease I need help completing this c++ program..pdf
Data Structures
Please I need help completing this c++ program. it was giving to complete it with no other
discriptions.
#include
using namespace std;
template
struct node
{
datatype info;
node *left, *right;
};
template
class tree
{
public:
tree();
~tree();
bool isempty();
void inserttree(datatype data);
void print();
private:
node *root;
};
template
tree::tree()
{
root = NULL;
}
template
void tree ::inserttree(datatype data)
{
node *temp;
temp = new node ;
temp->left = NULL;
temp->right = NULL;
temp->info = data;
if (root == NULL)
root = temp;
else
before = NULL;
after = root;
while (after != NULL)
{
b = a;
root
...;
else
}
if(temp->info< before->info)
before->left = temp;
else
before->right = temp;
//before = after;
//if (temp->info < after->info)
//after = after->left;
//else
//after = after->right;
//if(temp->info< before->info)
//before->left = temp;
//else
//before->right = temp;
}
template
void tree ::print(tree *temp)
{
if (temp != NULL)
{
print(temp->left);
cout << temp->info << endl;
print(temp->right);
}
p();
print(root);
}
int main()
{
tree t;
//put this in a loop
t.inserttree(90);
t.inserttree(80);
t.inserttree(108);
t.p();
}
Solution
// HEADER FILE FOR BINARY TREE//
// Define a structure to be used as the tree node
struct TreeNode
{
int Key;
float fValue;
int iValue;
char cArray[7];
TreeNode *left;
TreeNode *right;
};
class Code202_Tree
{
private:
TreeNode *root;
public:
Code202_Tree();
~Code202_Tree();
bool isEmpty();
TreeNode *SearchTree(int Key);
bool Insert(TreeNode *newNode);
bool Insert(int Key, float f, int i, char *cA);
bool Delete(int Key);
void PrintOne(TreeNode *T);
void PrintTree();
private:
void ClearTree(TreeNode *T);
TreeNode *DupNode(TreeNode * T);
void PrintAll(TreeNode *T);
};
#endif
//IMPLEMENTATION .CPP FILE FOR BINARY TREE//
#include
#include
#include \"Code202_Tree.h\"
using namespace std;
//--------------------------------------------
// Function: Code202_Tree()
// Purpose: Class constructor.
//--------------------------------------------
Code202_Tree::Code202_Tree()
{
root = NULL;
return;
}
//--------------------------------------------
// Function: Code202_Tree()
// Purpose: Class destructor.
//--------------------------------------------
Code202_Tree::~Code202_Tree()
{
ClearTree(root);
return;
}
//--------------------------------------------
// Function: ClearTree()
// Purpose: Perform a recursive traversal of
// a tree destroying all nodes.
//--------------------------------------------
void Code202_Tree::ClearTree(TreeNode *T)
{
if(T==NULL) return; // Nothing to clear
if(T->left != NULL) ClearTree(T->left); // Clear left sub-tree
if(T->right != NULL) ClearTree(T->right); // Clear right sub-tree
delete T; // Destroy this node
return;
}
//--------------------------------------------
// Function: isEmpty()
// Purpose: Return TRUE if tree is empty.
//--------------------------------------------
bool Code202_Tree::isEmpty()
{
return(root==NULL);
}
//--------------------------------------------
// Function.
JavaCreate a java application using the code example in the follo.pdf
Java:
Create a java application using the code example in the following URL regarding a binary search
tree structure:
CODE EXAMPLE:
class BST_class {
//node class that defines BST node
class Node {
int key;
Node left, right;
public Node(int data){
key = data;
left = right = null;
}
}
// BST root node
Node root;
// Constructor for BST =>initial empty tree
BST_class(){
root = null;
}
//delete a node from BST
void deleteKey(int key) {
root = delete_Recursive(root, key);
}
//recursive delete function
Node delete_Recursive(Node root, int key) {
//tree is empty
if (root == null) return root;
//traverse the tree
if (key < root.key) //traverse left subtree
root.left = delete_Recursive(root.left, key);
else if (key > root.key) //traverse right subtree
root.right = delete_Recursive(root.right, key);
else {
// node contains only one child
if (root.left == null)
return root.right;
else if (root.right == null)
return root.left;
// node has two children;
//get inorder successor (min value in the right subtree)
root.key = minValue(root.right);
// Delete the inorder successor
root.right = delete_Recursive(root.right, root.key);
}
return root;
}
int minValue(Node root) {
//initially minval = root
int minval = root.key;
//find minval
while (root.left != null) {
minval = root.left.key;
root = root.left;
}
return minval;
}
// insert a node in BST
void insert(int key) {
root = insert_Recursive(root, key);
}
//recursive insert function
Node insert_Recursive(Node root, int key) {
//tree is empty
if (root == null) {
root = new Node(key);
return root;
}
//traverse the tree
if (key < root.key) //insert in the left subtree
root.left = insert_Recursive(root.left, key);
else if (key > root.key) //insert in the right subtree
root.right = insert_Recursive(root.right, key);
// return pointer
return root;
}
// method for inorder traversal of BST
void inorder() {
inorder_Recursive(root);
}
// recursively traverse the BST
void inorder_Recursive(Node root) {
if (root != null) {
inorder_Recursive(root.left);
System.out.print(root.key + " ");
inorder_Recursive(root.right);
}
}
boolean search(int key) {
root = search_Recursive(root, key);
if (root!= null)
return true;
else
return false;
}
//recursive insert function
Node search_Recursive(Node root, int key) {
// Base Cases: root is null or key is present at root
if (root==null || root.key==key)
return root;
// val is greater than root's key
if (root.key > key)
return search_Recursive(root.left, key);
// val is less than root's key
return search_Recursive(root.right, key);
}
}
class Main{
public static void main(String[] args) {
//create a BST object
BST_class bst = new BST_class();
/* BST tree example
45
/ \
10 90
/ \ /
7 12 50 */
//insert data into BST
bst.insert(45);
bst.insert(10);
bst.insert(7);
bst.insert(12);
bst.insert(90);
bst.insert(50);
//print the BST
System.out.println("The BST Created with input data(Left-root-right):");
bst.inorder();
//delete leaf node
System.out.println("\nThe BST after Delete 12(leaf node):");
bst.
Help to implement delete_node get_succ get_pred walk and.pdf
Help to implement delete_node, get_succ, get_pred, walk, and tree_search in the script
following the given structure:
#include "bst.h"
// ---------------------------------------
// Node class
// Default constructor
Node::Node() {
// TODO: Implement this
key = 0;
parent = nullptr;
left = nullptr;
right = nullptr;
}
// Constructor
Node::Node(int in) {
// TODO: Implement this
key = in;
parent = nullptr;
left = nullptr;
right = nullptr;
}
// Destructor
Node::~Node() {
// TODO: Implement this
delete left;
delete right;
}
// Add parent
void Node::add_parent(Node* in) {
// TODO: Implement this
parent = in;
}
// Add to left of current node
void Node::add_left(Node* in) {
// TODO: Implement this
left = in;
if (in != nullptr) {
in->add_parent(this);
}
}
// Add to right of current node
void Node::add_right(Node* in) {
// TODO: Implement this
right = in;
if (in != nullptr) {
in->add_parent(this);
}
}
// Get key
int Node::get_key()
{
// TODO: Implement this
return key;
}
// Get parent node
Node* Node::get_parent()
{
// TODO: Implement this
return parent;
}
// Get left node
Node* Node::get_left()
{
// TODO: Implement this
return left;
}
// Get right node
Node* Node::get_right()
{
// TODO: Implement this
return right;
}
// Print the key to ostream to
// Do not change this
void Node::print_info(ostream& to)
{
to << key << endl;
}
// ---------------------------------------
// ---------------------------------------
// BST class
// Walk the subtree from the given node
void BST::inorder_walk(Node* in, ostream& to)
{
// TODO: Implement this
if (in != nullptr) {
inorder_walk(in->get_left(), to);
in->print_info(to);
inorder_walk(in->get_right(), to);
}
}
// Constructor
BST::BST()
{
// TODO: Implement this
root = nullptr;
}
// Destructor
BST::~BST()
{
// TODO: Implement this
delete root;
}
// Insert a node to the subtree
void BST::insert_node(Node* in)
{
// TODO: Implement this
Node* curr = root;
Node* par = nullptr;
while (curr != nullptr) {
par = curr;
if (in->get_key() < curr->get_key()) {
curr = curr->get_left();
} else {
curr = curr->get_right();
}
}
in->add_parent(par);
if (par == nullptr) {
root = in;
} else if (in->get_key() < par->get_key()) {
par->add_left(in);
} else {
par->add_right(in);
}
}
// Delete a node to the subtree
void BST::delete_node(Node* out)
{
// TODO: Implement this
}
// minimum key in the BST
Node* BST::tree_min()
{
// TODO: Implement this
return get_min(root);
}
// maximum key in the BST
Node* BST::tree_max()
{
// TODO: Implement this
return get_max(root);
}
// Get the minimum node from the subtree of given node
Node* BST::get_min(Node* in)
{
// TODO: Implement this
if (in == nullptr) {
return nullptr;
}
while (in->get_left() != nullptr) {
in = in->get_left();
}
return in;
}
// Get the maximum node from the subtree of given node
Node* BST::get_max(Node* in)
{
// TODO: Implement this
if (in == nullptr) {
return nullptr;
}
while (in->get_right() != nullptr) {
in = in->get_right();
}
return in;
}
// Get successor of the given node
Node* BS.
In c++ format please, for each function in the code, using the comme.pdf
In c++ format please, for each function in the code, using the comments fill in the function to
write the whole program.
#include
#include
using namespace std;
template
class BST
{
private:
struct Node
{
bstdata data;
Node* left;
Node* right;
Node(bstdata newdata): data(newdata), left(NULL), right(NULL) {}
};
typedef struct Node* NodePtr;
NodePtr root;
/**Private helper functions*/
void insertHelper(NodePtr root, bstdata value);
//private helper function for insert
//recursively inserts a value into the BST
void destructorHelper(NodePtr root);
//private helper function for the destructor
//recursively frees the memory in the BST
void inOrderPrintHelper(NodePtr root);
//private helper function for inOrderPrint
//recursively prints tree values in order from smallest to largest
void preOrderPrintHelper(NodePtr root);
//private helper function for preOrderPrint
//recursively prints tree values in preorder
void postOrderPrintHelper(NodePtr root);
//private helper function for postOrderPrint
//recursively prints tree values in postorder
/**Public functions*/
public:
BST();
//Instantiates a new Binary Search Tree
//post: a new Binary Search Tree object
~BST();
//frees the memory of the BST object
//All memory has been deallocated
bool isEmpty();
//determines whether the Binary Search Tree is empty
void insert(bstdata value);
//inserts a new value into the Binary Search Tree
//post: a new value inserted into the Binary Search Tree
bstdata getRoot();
//returns the value stored at the root of the Binary Search Tree
//pre: the Binary Search Tree is not empty
void inOrderPrint();
//calls the inOrderPrintHelper function to print out the values
//stored in the Binary Search Tree
//If the tree is empty, prints nothing
void preOrderPrint();
//calls the preOrderPrintHelper function to print out the values
//stored in the Binary Search Tree
//If the tree is empty, prints nothing
void postOrderPrint();
//calls the postOrderPrintHelper function to print out the values
//stored in the Binary Search Tree
//If the tree is empty, prints nothing
};
Solution
Below code is completed with the function prototypes :
#include
#include
using namespace std;
template
class BST
{
private:
struct Node
{
bstdata data;
Node* left;
Node* right;
Node(bstdata newdata): data(newdata), left(NULL), right(NULL) {}
};
typedef struct Node* NodePtr;
NodePtr root;
/**Private helper functions*/
void insertHelper(NodePtr root, bstdata value){
if(root==NULL)
{
NodePtr *newnode=new node;
newnode->data=value;
root=newnode;
}
else{
if(valuedata)
insertHelper(value,root->left);
else
insertHelper(value,root->right);
}
}
//private helper function for insert
//recursively inserts a value into the BST
void destructorHelper(NodePtr root);
//private helper function for the destructor
//recursively frees the memory in the BST
void inOrderPrintHelper(NodePtr root){
if (root != NULL)
{
inorder(root->left);
cout<data<right);
}
}
//private helper function for inOrderPrint
//recursively prints tree values in .
import javautilQueue import javautilLinkedList import .pdf
import java.util.Queue;
import java.util.LinkedList;
import java.util.NoSuchElementException;
public class BinaryTree<T extends Comparable<T>> {
BTNode root;
public BinaryTree() {
root = null;
}
public BinaryTree(BTNode root) {
root = null;
}
public void purge(){
root = null;
}
public boolean isEmpty(){
return root == null;
}
public void insert(T key){
if (root == null) {
root = new BTNode(key);
return;
}
BTNode temp;
Queue<BTNode> q = new LinkedList<BTNode>();
q.add(root);
// Do level order traversal until we find the first empty left or right child.
while (!q.isEmpty()) {
temp = q.poll();
if (temp.left == null) {
temp.left = new BTNode(key);
break;
}
else
q.add(temp.left);
if (temp.right == null) {
temp.right = new BTNode(key);
break;
}
else
q.add(temp.right);
}
}
// delete by copying last node
public void deleteByCopying(T data){
if(root == null)
throw new UnsupportedOperationException("Tree is empty!");
else if(root.left == null && root.right == null){
if(root.data.equals(data))
root = null;
else
throw new NoSuchElementException(data + " not in the tree.");
return;
}
Queue<BTNode> queue = new LinkedList<BTNode>();
queue.add(root);
BTNode keyNode = null;
BTNode currentNode = null;
BTNode parentNode = root;
boolean found = false;
while(! queue.isEmpty()){
currentNode = queue.poll();
if(currentNode.data.equals(data)){
if(! found){
keyNode = currentNode;
found = true;
}
}
if(currentNode.left != null){
queue.add(currentNode.left);
parentNode = currentNode;
}
if(currentNode.right != null){
queue.add(currentNode.right);
parentNode = currentNode;
}
}
if(! found)
throw new NoSuchElementException(data + " not in tree.");
while(! queue.isEmpty()){
currentNode = queue.poll();
System.out.print(currentNode.data + " ");
if(currentNode.left != null){
queue.add(currentNode.left);
parentNode = currentNode;
}
if(currentNode.right != null){
queue.add(currentNode.right);
parentNode = currentNode;
}
}
keyNode.data = currentNode.data;
if(parentNode.left == currentNode)
parentNode.left = null;
else if(parentNode.right == currentNode)
parentNode.right = null;
}
public void levelOrderTraversal(){ // BreadthFirstTraversal
levelOrderTraversal(root);
}
// BreadthFirst Traversal
protected void levelOrderTraversal(BTNode root){
if(root == null)
return;
Queue<BTNode> queue = new LinkedList<BTNode>();
BTNode node = root;
queue.add(node);
while(! queue.isEmpty()){
node = queue.poll();
visit(node);
if(node.left != null)
queue.add(node.left);
if(node.right != null)
queue.add(node.right);
}
}
public void levelOrderTraversalByLevels(){
levelOrderTraversalByLevels(root);
}
protected void levelOrderTraversalByLevels(BTNode<T> root){
Queue q = new LinkedList();
int levelNodes = 0;
if(root==null)
return;
q.add(root);
while(!q.isEmpty()){
levelNodes = q.size();
while(levelNodes>0){
BTNode n = (BTNode)q.remove();
System.out.print(" " + n.data);
if(n.left!=null)
q.add(n.left);
if(n.right!=null)
q.add(n.right);
levelNodes--;
}
System.out.println("");
}
}
protected void visit(BTNode<T.
Required to augment the authors Binary Search Tree (BST) code to .docx
Required to augment the author's Binary Search Tree (BST) code to support these new operations. Method names below are merely suggestions. (The author’s class is attached separately in the file called “authordoc”. I just built a simple test tree in the author’s main method which can be used to test the various operations. )
1. AnyType nthElement(int n) -- returns the n-th element (starting from 1) of the in-order traversal of the BST.
2. int rank( AnyType x ) -- returns the "rank" of x. The rank of an element is its position (starting with 1) in an in-order traversal.
3. AnyType median( ) -- returns the median (middle) element in the BST. If the BST contains an even number of elements, returns the smaller of the two medians.
4. boolean isPerfect( ) -- returns true if the BST is a perfect binary tree.
5. boolean isComplete( ) -- returns true if the BST is a complete binary tree.
6. String toString( int nrLevels ) -- generates the level-order output described in the sample output below.
Most of these operations could easily be implemented by performing an in-order traversal inside the BST and perhaps placing the results in an ArrayList. However, such a method is extremely inefficient. Instead, we are going to achieve faster performance by "augmenting" the BST nodes. You will add a new private integer data member ("tree size") to the BinaryNode which stores the size of the tree rooted at that node (including the root). You must develop your own algorithms for these operations, but obviously you will use the new tree size data member to guide your search. Think before you code and think recursively!
These items cover those topics not addressed elsewhere in the project description. (R) indicates a requirement, (H) indicates a hint, and (N) indicates a note.
1. (R) Although we are only using the BST for integers, the BST must remain a generic class.
2. (R) Duplicate values are not allowed. Attempts to insert a duplicate value should be ignored.
3. (R) Attempts to remove non-existent values should be ignored.
4. (R) From a coding perspective, the easiest way to avoid duplicate insertions or attempting to remove non-existent elements is to first call find( ). However, this technique is NOT permitted for two reasons.
Calling find( ) before each insert/remove doubles the running time for these operations and is therefore inefficient.
Recusively coding the insert/remove methods to handle these situations is a great learning experience.
5. (R) The level order print (PRINT command) outputs the value of each node, the size of the tree rooted at that node, and the value of the node's parent in that order, inside parenthesis, separated by commas. (node value, tree size, parent value). Since the root has no parent, print NULL for the root's parent value. For readability, separate the levels with a blank line and print no more than 6 node/size/parent values per line. If a level requires multiple lines, use consecutive lines (without a blank line between the ...
Please finish everything marked TODO BinaryNode-java public class Bi.docx
Please finish everything marked TODO
BinaryNode.java
public class BinaryNode<E extends Comparable<E>> implements TreePrinter.PrintableNode{
private E data;
private BinaryNode<E> left;
private BinaryNode<E> right;
private int height;
private int size;
private BinaryNode<E> parent;
public BinaryNode(E data){
this.data = data;
this.left = null;
this.right = null;
this.parent = null;
this.height = 1;
this.size = 1;
}
// TODO: Set up the BinaryNode
public BinaryNode(E data, BinaryNode<E> left, BinaryNode<E> right, BinaryNode<E> parent){
}
// Access fields
E data() { return this.data; };
BinaryNode<E> left() {
return this.left;
}
BinaryNode<E> right() {
return this.right;
}
BinaryNode<E> parent() { return this.parent; }
// Setter fields
void setLeft(BinaryNode<E> left) {
this.left = left;
if(left != null) left.setParent(this);
}
void setRight(BinaryNode<E> right) {
this.right = right;
if(right != null) right.setParent(this);
}
void setParent(BinaryNode<E> parent) {
this.parent = parent;
}
void setData(E data) { this.data = data; }
void setHeight(int h){
this.height = h;
}
// Basic properties
int height() {
return this.height;
}
int size() { return this.size; }
boolean isBalanced() {
int leftHeight = (hasLeft()) ? left.height() : 0;
int rightHeight = (hasRight()) ? right().height() : 0;
return Math.abs(leftHeight - rightHeight) < 2;
}
boolean hasLeft(){
return left == null ? false : true;
}
boolean hasRight(){
return right == null ? false :true;
}
boolean hasParent(){
return parent == null ? false :true;
}
public boolean equals(BinaryNode<E> other){
if(other == null) return false;
return other.data.equals(this.data);
}
// Can use these to help debug
public TreePrinter.PrintableNode getLeft() {
return left == null ? null : left;
}
public TreePrinter.PrintableNode getRight() {
return right == null ? null : right;
}
public String getText() {
return String.valueOf(data);
}
public String toString(){
String ret = "";
return "root " + this.data + " Left: " +(hasLeft() ? left.data : null) + " Right: " +(hasRight() ? right.data : null) +
" parent: " + (hasParent() ? parent.data : null) ;
}
}
BST.java
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class BST<E extends Comparable<E>> implements Tree<E> {
private int height;
private int size;
private BinaryNode<E> root;
public BST(){
this.root = null;
this.height = 0;
this.size = 0;
}
// TODO: BST
public BST(BinaryNode<E> root){
}
// Access field
public BinaryNode<E> root() {
return this.root;
}
// Basic properties
public int height() {
return this.height;
}
public int size() {
return this.size;
}
public boolean isBalanced() {
return root.isBalanced();
}
// TODO: updateHeight - Update the root height to reflect any changes
public void updateHeight() {
}
// Traversals that return lists
// TODO: Preorder traversal
public List<E> preOrderList() {
return new ArrayList<>();
}
// .
public class Deque {private class Node {public int data;public.pdf
Given interval is `[0,2pi]` .
And given identity is `secx+tanx=1`
which we can write as `1/(cosx)+(sinx)/(cosx)=1`
`or` , `(1+sinx)/(cosx)=1`
or, `(1+sinx)=cosx`
or, `1+sinx-cosx=0`
or, `1+2sin(x/2)cos(x/2)-(1-2sin^2(x/2))=0`
or, `1+2sin(x/2)cos(x/2)-1+2sin^2(x/2)=0`
or, `2sin(x/2)cos(x/2)+2sin^2(x/2)=0`
or, `2sin(x/2)[cos(x/2)+sin(x/2)]=0`
`or,` `2sin(x/2)=0` and `cos(x/2)+sin(x/2)=0` .
Now, `2sin(x/2)=0` `rArrsin(x/2)=0` `rArrsin(x/2)=sin(npi)` , n=0,1,2. As per the need of our
problem.
`rArr x/2=npi` or, `x=2npi` for n=0,1 as our interval is `[0,2pi]` .
So, `x=0` or, `x=2pi` .
Now, if `cos(x/2)+sin(x/2)=0` `rArr1+(sin(x/2))/cos(x/2)=0`
`rArrtan(x/2)=-1` or, `tan(x/2)=tan(pi/2+pi/4)`
or, `x/2=(pi/2+pi/4)`
or, `x=pi+pi/2`
or, `x=3pi/2` .
Clearly, `x=0` and `x=2pi` are the solutions satisfying our given identity over the given interval.
Solution
Given interval is `[0,2pi]` .
And given identity is `secx+tanx=1`
which we can write as `1/(cosx)+(sinx)/(cosx)=1`
`or` , `(1+sinx)/(cosx)=1`
or, `(1+sinx)=cosx`
or, `1+sinx-cosx=0`
or, `1+2sin(x/2)cos(x/2)-(1-2sin^2(x/2))=0`
or, `1+2sin(x/2)cos(x/2)-1+2sin^2(x/2)=0`
or, `2sin(x/2)cos(x/2)+2sin^2(x/2)=0`
or, `2sin(x/2)[cos(x/2)+sin(x/2)]=0`
`or,` `2sin(x/2)=0` and `cos(x/2)+sin(x/2)=0` .
Now, `2sin(x/2)=0` `rArrsin(x/2)=0` `rArrsin(x/2)=sin(npi)` , n=0,1,2. As per the need of our
problem.
`rArr x/2=npi` or, `x=2npi` for n=0,1 as our interval is `[0,2pi]` .
So, `x=0` or, `x=2pi` .
Now, if `cos(x/2)+sin(x/2)=0` `rArr1+(sin(x/2))/cos(x/2)=0`
`rArrtan(x/2)=-1` or, `tan(x/2)=tan(pi/2+pi/4)`
or, `x/2=(pi/2+pi/4)`
or, `x=pi+pi/2`
or, `x=3pi/2` .
Clearly, `x=0` and `x=2pi` are the solutions satisfying our given identity over the given interval..
package lab7 public class SetOperations public static.pdf
package lab7;
public class SetOperations {
public static int[] makeSet(int[] data) {
if (data == null) {
return null;
}
int[] result = new int[data.length];
int index = 0;
boolean found;
for (int i = 0; i < data.length; i++) {
found = false;
for (int j = 0; j < index; j++) {
if (data[i] == result[j]) {
found = true;
break;
}
}
if (!found) {
result[index++] = data[i];
}
}
int[] finalResult = new int[index];
System.arraycopy(result, 0, finalResult, 0, index);
return finalResult;
}
public static boolean isSet(int[] data) {
if (data == null) {
return false;
}
for (int i = 0; i < data.length; i++) {
for (int j = i + 1; j < data.length; j++) {
if (data[i] == data[j]) {
return false;
}
}
}
return true;
}
public static int[] union(int[] setA, int[] setB) {
if (!isSet(setA) || !isSet(setB)) {
throw new IllegalArgumentException("One of the input arrays is not a set");
}
int[] result = new int[setA.length + setB.length];
int index = 0;
for (int i = 0; i < setA.length; i++) {
result[index++] = setA[i];
}
boolean found;
for (int i = 0; i < setB.length; i++) {
found = false;
for (int j = 0; j < setA.length; j++) {
if (setB[i] == setA[j]) {
found = true;
break;
}
}
if (!found) {
result[index++] = setB[i];
}
}
int[] finalResult = new int[index];
System.arraycopy(result, 0, finalResult, 0, index);
return finalResult;
}
public static int[] intersection(int[] setA, int[] setB) {
if (!isSet(setA) || !isSet(setB)) {
throw new IllegalArgumentException("One of the input arrays is not a set");
}
int[] smallerSet, largerSet;
if (setA.length < setB.length) {
smallerSet = setA;
largerSet = setB;
} else {
smallerSet = setB;
largerSet = setA;
}
int[] result = new int[smallerSet.length];
int index = 0;
for (int i = 0; i < smallerSet.length; i++) {
for (int j = 0; j < largerSet.length; j++) {
if (smallerSet[i] == largerSet[j]) {
result[index++] = smallerSet[i];
break;
}
}
}
int[] finalResult = new int[index];
System.arraycopy(result, 0, finalResult, 0, index);
return finalResult;
}
public static int[] difference(int[] setA, int[] setB) {
if (!isSet(setA) || !isSet(setB)) {
throw new IllegalArgumentException("One of the input arrays is not a set");
}
int[] diff = new int[setA.length];
int index = 0;
for (int i = 0; i < setA.length; i++) {
boolean found = false;
for (int j = 0; j < setB.length; j++) {
if (setA[i] == setB[j]) {
found = true;
break;
}
}
if (!found) {
diff[index++] = setA[i];
}
}
int[] result = new int[index];
System.arraycopy(diff, 0, result, 0, index);
return result;
}
}
Lab 7: Set Operations with Arrays Grading and Submission You are to write a complete Java
program that meets the requirements outlined in the Lab 7 Tasks section. Push your code to
GitHub in the same way you've pushed previous Labs: - Your code should be in a class named
"SetOperations.java" and in a package named "lab7" - So, the path to your code should be:
"Labs/Lab07/src/lab7/SetOperations.java" There will be 6 points for this lab, broken down in the
following way: 1. makeSet is implement.
How to do the main method for this programBinaryNode.javapublic.pdf
How to do the main method for this program?
BinaryNode.java
public class BinaryNode
implements Parent{
/** The item associated with this node. */
private E item;
/** The node at the root of the left subtree. */
private BinaryNode left;
/** The node at the root of the right subtree. */
private BinaryNode right;
/** Put item in a leaf node. */
public BinaryNode(E item) {
this.item = item;
// left and right are set to null by default
}
/** no-argument constructor sets everything to null */
public BinaryNode() {
item = null;
left = null;
right = null;
}
/** Put item in a node with the specified subtrees. */
public BinaryNode(E item, BinaryNode left,
BinaryNode right) {
this.item = item;
this.left = left;
this.right = right;
}
/** Put item in a node with the specified subtrees. */
public BinaryNode getChild(int direction) {
if (direction < 0) {
return left;
} else {
return right;
}
}
/** Return the item associated with this node. */
public E getItem() {
return item;
}
/** Return the root of the left subtree. */
public BinaryNode getLeft() {
return left;
}
/** Return the root of the right subtree. */
public BinaryNode getRight() {
return right;
}
/** Return true if this is a leaf. */
public boolean isLeaf() {
return (left == null) && (right == null);
}
/** Replace the item associated with this node. */
public void setItem(E item) {
this.item = item;
}
/** Replace the left subtree with the one rooted at left. */
public void setLeft(BinaryNode left) {
this.left = left;
}
/** Replace the right subtree with the one rooted at right. */
public void setRight(BinaryNode right) {
this.right = right;
}
public void setChild(int direction, BinaryNode child) {
if (direction < 0) {
left = child;
} else {
right = child;
}
}
/**
* Return the String representation of the tree rooted at this node
* traversed preorder.
**/
public String toStringPreorder() {
String result = \"\";
result += item;
if (left != null) {
result += left.toStringPreorder();
}
if (right != null) {
result += right.toStringPreorder();
}
return result;
}
/** Return a String representation of the tree rooted at this node
* traversed inorder.
**/
public String toStringInOrder() {
String result = \"\";
if (left != null) {
result += left.toStringInOrder();
}
result += item;
if (right != null) {
result += right.toStringInOrder();
}
return result;
}
/** Return a String representation of the tree rooted at this node,
* traversed postorder.
**/
public String toStringPostorder() {
String result = \"\";
if (left != null) {
result += left.toStringPostorder();
}
if (right != null) {
result += right.toStringPostorder();
}
result += item;
return result;
}
/**
* Return a String representation of the tree rooted at this node,
* traversed level order.
**/
public String toStringLevelOrder() {
String result = \"\";
Queue> q = new ArrayQueue>();
q.add (this);
while (!(q.isEmpty())) {
BinaryNode node = q.remove ();
result += node.item;
if (node.left != null) {
q.add(node.left);
}
if (node.right != null) {
q.add(node..
1)(JAVA) Extend the Binary Search Tree ADT to include a public metho.pdf
1)(JAVA) Extend the Binary Search Tree ADT to include a public method leafCount that returns
the number of leaf nodes in the tree.
Thank You in Advanced.
Below, I also have attached the BinarySearchTree and the Interface File.
BinarySearchTree:
//----------------------------------------------------------------------------
// BinarySearchTree.java by Dale/Joyce/Weems Chapter 8
//
// Defines all constructs for a reference-based BST
//----------------------------------------------------------------------------
package ch08.trees;
import ch05.queues.*;
import ch03.stacks.*;
import support.BSTNode;
public class BinarySearchTree>
implements BSTInterface
{
protected BSTNode root; // reference to the root of this BST
boolean found; // used by remove
// for traversals
protected LinkedUnbndQueue inOrderQueue; // queue of info
protected LinkedUnbndQueue preOrderQueue; // queue of info
protected LinkedUnbndQueue postOrderQueue; // queue of info
public BinarySearchTree()
// Creates an empty BST object.
{
root = null;
}
public boolean isEmpty()
// Returns true if this BST is empty; otherwise, returns false.
{
return (root == null);
}
private int recSize(BSTNode tree)
// Returns the number of elements in tree.
{
if (tree == null)
return 0;
else
return recSize(tree.getLeft()) + recSize(tree.getRight()) + 1;
}
public int size()
// Returns the number of elements in this BST.
{
return recSize(root);
}
public int size2()
// Returns the number of elements in this BST.
{
int count = 0;
if (root != null)
{
LinkedStack> hold = new LinkedStack>();
BSTNode currNode;
hold.push(root);
while (!hold.isEmpty())
{
currNode = hold.top();
hold.pop();
count++;
if (currNode.getLeft() != null)
hold.push(currNode.getLeft());
if (currNode.getRight() != null)
hold.push(currNode.getRight());
}
}
return count;
}
private boolean recContains(T element, BSTNode tree)
// Returns true if tree contains an element e such that
// e.compareTo(element) == 0; otherwise, returns false.
{
if (tree == null)
return false; // element is not found
else if (element.compareTo(tree.getInfo()) < 0)
return recContains(element, tree.getLeft()); // Search left subtree
else if (element.compareTo(tree.getInfo()) > 0)
return recContains(element, tree.getRight()); // Search right subtree
else
return true; // element is found
}
public boolean contains (T element)
// Returns true if this BST contains an element e such that
// e.compareTo(element) == 0; otherwise, returns false.
{
return recContains(element, root);
}
private T recGet(T element, BSTNode tree)
// Returns an element e from tree such that e.compareTo(element) == 0;
// if no such element exists, returns null.
{
if (tree == null)
return null; // element is not found
else if (element.compareTo(tree.getInfo()) < 0)
return recGet(element, tree.getLeft()); // get from left subtree
else
if (element.compareTo(tree.getInfo()) > 0)
return recGet(element, tree.getRight()); // get from right subtree
else
return tree.getInfo(); // element is found
}
public T get(T.
Similar to To create a node for a binary search tree (BTNode, ) and to create a .pdf (20)
Tree Traversals A tree traversal is the process of visiting.pdf
Tree Traversals A tree traversal is the process of visiting.pdf
10 Solution#include-iostream-h- #include-conio-h- #include-process-h-.docx
10 Solution#include-iostream-h- #include-conio-h- #include-process-h-.docx
Create a class BinarySearchTree- A class that implements the ADT binar.pdf
Create a class BinarySearchTree- A class that implements the ADT binar.pdf
5. Design and implement a method contains 2 for BinarySearchTree, fu.pdf
5. Design and implement a method contains 2 for BinarySearchTree, fu.pdf
Objective Binary Search Tree traversal (2 points)Use traversal.pp.pdf
Objective Binary Search Tree traversal (2 points)Use traversal.pp.pdf
Write a function in C++ to generate an N-node random binary search t.pdf
Write a function in C++ to generate an N-node random binary search t.pdf
A)B) C++ program to create a Complete Binary tree from its Lin.pdf
A)B) C++ program to create a Complete Binary tree from its Lin.pdf
Data StructuresPlease I need help completing this c++ program..pdf
Data StructuresPlease I need help completing this c++ program..pdf
JavaCreate a java application using the code example in the follo.pdf
JavaCreate a java application using the code example in the follo.pdf
Help to implement delete_node get_succ get_pred walk and.pdf
Help to implement delete_node get_succ get_pred walk and.pdf
In c++ format please, for each function in the code, using the comme.pdf
In c++ format please, for each function in the code, using the comme.pdf
import javautilQueue import javautilLinkedList import .pdf
import javautilQueue import javautilLinkedList import .pdf
Required to augment the authors Binary Search Tree (BST) code to .docx
Required to augment the authors Binary Search Tree (BST) code to .docx
Please finish everything marked TODO BinaryNode-java public class Bi.docx
Please finish everything marked TODO BinaryNode-java public class Bi.docx
public class Deque {private class Node {public int data;public.pdf
public class Deque {private class Node {public int data;public.pdf
package lab7 public class SetOperations public static.pdf
package lab7 public class SetOperations public static.pdf
How to do the main method for this programBinaryNode.javapublic.pdf
How to do the main method for this programBinaryNode.javapublic.pdf
1)(JAVA) Extend the Binary Search Tree ADT to include a public metho.pdf
1)(JAVA) Extend the Binary Search Tree ADT to include a public metho.pdf
More from bhim1213
In 1998, Congress passed legislation concerning shifting the burden .pdf
In 1998, Congress passed legislation concerning shifting the burden of proof to the IRS. The
taxpayer must introduce \"credible evidence\" to shift the burden of proof to the IRS. What
constitutes \"credible evidence?\"
Solution
Credible evidence is not evidence which is necessarily true, but is evidence worthy of belief, that
is, worthy to be considered by the jury. It is often natural, reasonable and probable as to make it
easy to believe.
Pursuant to 89 Ill. (Adm. Code 300.20), \"Credible evidence of child abuse or neglect\" means
that the available facts, when viewed in light of surrounding circumstances, would cause a
reasonable person to believe that a child was abused or neglected.”
The 1998 tax law has provided that the burden of proof in tax court cases will be on the
government, not the taxpayer. However, it also provides that this can be shifted back to the
taxpayer in a number of circumstances, mostly involving lack of taxpayer cooperation with
examinations. The issue of who bears the burden of proof is important, even if your case, like
most, never goes as far as the tax court. This is because the burden will operate as a background
issue that will tend to help to affect the settlement posture of both the taxpayer and the IRS.
The burden of production, also known as the burden of going forward, is the burden of providing
sufficient evidence on an issue in order to prevail in the dispute. In Tax Court cases initiated by
the IRS, the government bears the burden of production. IRS is internal reserve service.
In order to avoid a shift-back in the burden of proof, the taxpayer must meet his burden of
production. That is, the
taxpayer must meet his record-keeping, substantiation, and cooperation requirements.
Conclusion:
The Restructuring and Reform Act of 1998 allows for the shift of the burden of proof from
taxpayers to the government, and generally serves to protect the interests of taxpayers who are
being audited by the IRS. This policy change benefits taxpayers, who previously had been
saddled with the burden of proof in almost all civil tax matters. Taxpayers must provide
substantial and credible evidence, meet record-keeping and substantiation requirements, and
cooperate with the IRS. The burden of proof oftentimes does not shift to the IRS because the
taxpayer feels to meet one of these important provisions. For this reason, the IRS Restructuring
and Reform Act of 1998 does not always provide taxpayers much relief from the previous
system. From a practical standpoint, meticulous and accurate record-keeping is of the most
important so that the taxpayer may be able to shift the burden of proof to IRS..
If A denotes some event, what does A denote If P(A)equals=0.997, wh.pdf
If A denotes some event, what does A denote? If P(A)equals=0.997, what is the value of P(A)? If
P(A)equals=0.997, is A unusual?
Solution
Sol)
P(not A)=0.003 (1-0.997=0.003) P(not A) , meaning that compliment of A consists of all
outcomes(results) in which event A does not occur. It is not unusual(only outcomes <0.05 are
unusual)..
How do neutrophils find and get to an infectionSolutionNeutro.pdf
How do neutrophils find and get to an infection?
Solution
Neutrophils nucleus has a complex, lobulated shape. In a cross-section, neutrophils look like they
have more than one nucleus. Neutrophils have this unique nuclear shape, it makes these cells
very easy to identify under the microscope. They are very abundant, making up about 60% of the
immune cells in our blood. They are formed from stem cells in the bone marrow. Neutrophils
derives from staining characteristics on hematoxylin and eosin (H&E) histological or cytological
preparations. Neutrophils are the first cells to migrate to a site of infection, and with the help of
other innate immune cells, they work hard to keep things under control until the powerful
adaptive immune system kicks..
How many times will the following code print Welcome to Java in.pdf
How many times will the following code print \"Welcome to Java\"? int count = 0; while
(count
Solution
Ans)
15) D.10
public class MultiQues {
public static void main(String[] args) {
// TODO Auto-generated method stub
int count = 0;
while(count < 10){
System.out.println(\"welcome to java\");
count++;
}
}
}
16) E.45
public class MultiQues {
public static void main(String[] args) {
// TODO Auto-generated method stub
int y = 0;
for(int i=0;i<10;++i){
y+=i;
}
System.out.println(y);
}
}
17) B.10
public class MultiQues {
public static void main(String[] args) {
// TODO Auto-generated method stub
int y = 0;
int i=0;
for(i=0;i<10;++i){
y+=i;
}
System.out.println(i);
}
}
18) B.n
There are n iterations for the given for loop because it is given that i=1 to i <= n so there
aren iterations.
19) C.n-1
Here for loop starts from i=1 to i.
From your own words not copy past from internet please Talked about.pdf
From your own words not copy past from internet please Talked about\" allergies\".
Thanks.
Solution
Dear User, you have not mentioned the words limit in your question. so, a brief description of
Allergies is provided below in my own words.
Answer) Allergies are referred to several reactions or response as an outcome of hypersensitive
reaction of our body’s immune system, when exposed to several allergic substances. these
allergic substances are called as allergen. there are number of common allergens such as Dust
mites, Pollens, Insect stings, Pet dander, Mold spores, Food, household chemicals and
Medicines. these substances are not always allergic as the other people are not allergic to them,
but some people are allergic to them. our immune system makes antibodies against the foreign
particles entering our body. in case, when our immune system is weak (particularly in children) it
is possible that encounter of such allergic substances during weak immunity may result in
hypersensitive reaction. this first-time hypersensitive response is called as acute response when
our immune system starts making antibodies against those substances. further multiple exposures
to same allergens result in a higher response and the person becomes allergic to those substances.
symptoms of allergies are sneezing, wheezing and coughing, a running nose or blocked nose, a
red itchy rash, red itchy watery eyes. these symptoms can be observed within minutes of
exposure to allergens. generally, these responses are mild but a prolonged hypersensitive reaction
may result in anaphylaxis or anaphylactic shock which is a medical emergency.
As per studies, one out of five American is affected with some sort of allergies. and the allergies
are more commonly observed in the developed countries. there are different diagnostic tests to
identify whether a person has an allergic response to possible allergens or not. these tests include
patch testing, skin prick testing, blood testing etc. in these tests, a much smaller dose of allergen
is provided to the person to observe the immune response. once a person is identified allergic to
certain substance, it is consulted to avoid the exposure to those substances. while, in case of
sudden exposure they are provided with the medications such as antihistamines, epinephrine and
glucocorticoids etc. under certain limitations, immunotherapy is also provided as treatment
against and asthma and allergies to insect bites..
Forms an important part of the subunits of the ribosome. The _ are sp.pdf
Forms an important part of the subunits of the ribosome. The _ are spliced back together to form
the mRNA molecule. Is a nucleic acid that directs the production of proteins?
Solution
Protein forms an important part in the subunits of ribosomes.
The precursor messenger RNA is spliced back together to form the mRNA molecule.
Yes,nucleic acid (DNA or RNA) directs the production of proteins. They have informations for
the process of gene expression..
During DNA replication, a series of steps are required to ensure tha.pdf
During DNA replication, a series of steps are required to ensure that the genetic information in a
cell is correctly and accurately duplicated. Place the following phrases in the correct order.
Binding proteins stabilize the unwound double helix.
DNA helicase unwinds the DNA double helix.
Topoisomerase IV separates linked chromosomes.
DNA pol III adds complementary nucleotides.
DNA ligase seals any nicks in the DNA.
DNA pol I replaces the RNA primer.
Primase generates a RNA primer that binds to the origin.
Solution
During DNA replication, a correct order of steps takes place to ensure that the genetic
information in a cell is correctly and accurately duplicated..
Disease X occurs when someone has the xx genotype. However, only 20 .pdf
Disease X occurs when someone has the xx genotype. However, only 20 of 50 people with the
xx genotype actually get the disease. Of the 20 who get disease X, 10 severely display the
disease while 10 have a milder form. Explain using the appropriate terms.
Solution
Answer: XX genotype indicate that it is a autosomal recessively inherited trait and it is female.
sickle cell anaemia is one best example which match these results.
XhXh = Homozygous dominnant (10 people are severely effected).
XXh = heterozygous dominant (10 people may act as carriers) which are milder forms..
Darwins Theory had five main tenets (or components), what are they.pdf
Darwin\'s Theory had five main tenets (or components), what are they? ). These are not to be
confused with the logic of Natural Selection, which is sometimes referred to as the tenets of
Darwin’s theory
Solution
5 major tenets of Darwins theory are :
1. The evolution stating that the world is directionally getting transformed continuously with tha
passage of time,
2. The common descent which states that every group of the branching organism has decended
from a common ancestor
3. The gradualism which states that during evolution, the transformation happens very gradually
not at once,
4. The multiplication of species which states that the sympatric speciation leads to the
diversification in species, and
5. The natural selection which states that the evolutionary change happens due to the survival of
the fittest because the most fit would have a reproductive advantage, generation after generation..
Define toxic shock syndrome (TSS) impetigo MRSASolutionAnswer.pdf
Define: toxic shock syndrome (TSS) impetigo MRSA
Solution
Answer:
1. Toxic Shock Syndrome (TSS): It is a severe human disease caused by bacteria Staphylococcus
aureus. The bacteria produced superantigens which act as a toxins (mainly Toxic Shock
Syndrome Toxin-1) to cause this syndrome. Superantigens are bacterial proteins that stimulate
the immune system much more extensively than do normal antigens. As they provoke such a
drastic immune response thus, they are termed superantigens. Their action is to stimulate T cells
to proliferate nonspecifically through simultaneous interaction with class II MHC proteins on
antigen-presenting cells and variable regions on the chain of the T-cell receptor complex.
It is most commonly seen in females who use superabsorbent tampons during menstruation.
However, the toxin associated with this syndrome is also produced in men and in
nonmenstruating women by S. aureus present at sites other than the genital area such as surgical
wound infections.
Symptoms: Low blood pressure, fever, diarrhea, an extensive skin rash (like sun burn), and
ultimately shedding of the skin.
2. Impetigo: It is the most frequently diagnosed skin (superficial cutaneous) infection caused by
bacteria Staphylococcuspyogenes and S. aureus. It is most commonly seen in children.
Symptoms: The encrusted pustules, crusty lesions and vesicles surrounded by a red border,
usually located on the face.
3. MRSA (Methicillin Resistant Staphylococcusaureus): Bacteria Staphylococcus aureus is a
cause of considerable morbidity and mortality as a nosocomial or hospital-acquired pathogen
since late 1950s and early 1960s. However, penicillinase-resistant, semisynthetic penicillins have
proved to be successful antimicrobial agents in the treatment of staphylococcal infections. But it
is unfortunate that the staphylococci become resistant through procuring of a chromosomal gene
(mecA) that encodes an alternate target protein which is not inactivated by methicillin. The
majority of the strains are resistant to several of the most commonly used antimicrobial agents,
including macrolides, aminoglycosides, and the beta-lactam antibiotics, including the latest
generation of cephalosporins. Thus, MSRA strains have recently emerged as a major, difficult to
treat, hospital-acquired infection in humans, therefore considered as super-bug..
A system was set up in parallel with two components, A and B. The pr.pdf
A system was set up in parallel with two components, A and B. The probability of failure for A
is .20 and for B is .10. In order for the system to fail, both must fail. What is the probability of a
system failure?
Solution
P( system to fail, both must fail ) = 1 - P( A Fail) * P( B Fail) = 1 - [ (1-0.20) ( 1-0.10) ] = 1 -
0.72 = 0.28.
All content is made permanent for future use. All content will be lo.pdf
All content is made permanent for future use. All content will be lost. How would a port most
likely be used? A. To connect additional input, output, communication devices to a PC
Solution
Question 7
A bay would most likely hold a HARD DRIVE.
A hard drive is a component that is installed in a bay inside the system case..
a. A waitress is serving 5 people at a table. She has the 5 dishes t.pdf
a. A waitress is serving 5 people at a table. She has the 5 dishes they ordered (all 5 different), but
she can\'t remember who gets what. How many different possible way are there for her to give
the 5 dishes to the 5 people? Explain you answer
b. Based on part (a), if the waitress just hands the dishes out randomly, what is the probability
that she will hand the dishes out correctly
Solution
a. A waitress is serving 5 people at a table. She has the 5 dishes they ordered (all 5 different),
but she can\'t remember who gets what. How many different possible way are there for her to
give the 5 dishes to the 5 people? Explain you answer different possible ways = 5! =120
WAYS different possible ways first person get dish =5 different possible ways second
person get dish =4 different possible ways third person get dish =3 different possible ways
fourth person get dish =2 different possible way fifth person get dish =1 different possible
ways = 5*4*3*2*1 =120 b. Based on part (a), if the waitress just hands the dishes out
randomly, what is the probability that she will hand the dishes out correctly probability =
1/120 =0.0083.
Biochemistry homework Focus concept ripening fruit and the activity.pdf
Biochemistry homework: Focus concept ripening fruit and the activity tin methyl- The link
between the production of methanol in wild type and transgenic tomato esterase, the enzyme
responsible for methanol production, is examined in fruit. Prerequisite Enzyme kinetics and
inhibition. Background major source ofthis methanol is likely Methanol is produced by fruit
during the ripening process. The to be from the enzyme p methylesterase which acts upon pectin
methyl esters to de-esterify them and produce methanol and other pectic substances One might
assume that the production of methanol is correlated with PME activity, but this has not been
firmly established. In this case, the investigators at the Plant Science Department at Rutgers
University developed a transgenic tomato which was deficient in PME activity. By comparing
the behavior of the transgenic tomato with the wild type tomato, the production of methanol in
the ripening tomato fruit may be better understood. Questions breaker (Br), turning (Tru) and red
ripe (RR) tomatoes. They also determined the amount of PME protein present by using a
Western blot assay, which uses a specific antibody to detect the PME protein. The results are
shown in Figure 12.1. What is your interpretation ofthese results? Transgenio ING MG Be
Figure 12.1: PME protein levels (A) and activ- ity (B) in wild-type and transgenic tomatoes.
(Modified from Frenkel, et al. 1998.)
Solution
As given in A the protein level of PME is completely negligible in transgenic variety and present
in wild type. In wild type variety the protein level in less in the IMG stage as compared to the
subsequent stages this is because the expression of PME increases as the ripening of tomato
increases.
in fig. B : In the case of activity of the PME in the wild type variety increase is shown until it
reaches the Tu stage and it starts decreasing in the fully ripening stage since the PME activity is
not required to do the ripening.
little activity in the transgenic variety is also shown because of the endogenous expression of
PME because the PME is only altered not fully knockout.
A process that has its representative PCB in a device queue is in th.pdf
A process that has its representative PCB in a device queue is in the _____ state.
New
ready
running
terminated
blocked or waiting
Solution
When a process in currently running in the cpu and suddenly have to wait for i/o then scheduler
save its state ( program counter registers) into pcb and then add to the device queue which
process Wait for i/o from it. So here answer is waiting.
Which of the following statements is (are) trueI Cash flow is a.pdf
Which of the following statements is (are) true:
I : Cash flow is about predicting when money will come in and will go out.
II: Cash flow is not about making sure that there is enough money to pay your debts.
Both statements are true
Solution
Answer: Both statements are false
Explanation:
Both the Statements are false because cash flow can be termed as total net amount of money
being transfered into and out of business, specifically as effecting liquidity. So, Cash neither
predicting nor making sure..
What is the relationship of the epithelium of the epidermis to the co.pdf
What is the relationship of the epithelium of the epidermis to the connective tissues layers of the
dermis? Describe the boundary between the epidermis and dermis and the various types of
connective tissues that compose the dermis.
Solution
Epidermis is a type of epithelium tissue containing typically thin sheets of cells. Epidermis forms
the outermost layer of the skin containing 4 to 5 layers of epithelial cells.The outermost part of
the epidermis is comprises of flattened cells in stratified layers overlying on a basal layer
(stratum basale) made up of columnar cells arranged perpendicularly. Beneath the epidermis lies
the middle layer called dermis layer. It is composed of dense irregular connective tissue and
areolar connective tissue such as a collagen with elastin arranged in bundled and woven pattern.
This layer comprise of the papillary and reticular layers. Dermis contains connective tissues,
vessels, glands, follicles, hair roots and sensory nerve endings.
This superficial paillary layer of the dermis, made up of areolar connective tissue like collagen
and elastin fibers in a loose mesh, projects itself into the stratum basale of the epidermis to form
finger-like dermal papillae. The dermis layer also consists of blood and lymph vessels and
nerves, which end in epidermal layer and also hair follicles and sweat glands which project out
through epidermis.
Thus dermis is the layer of the skin between the epidermic and the subcutaneous tissues,
primarily composed of dense irregulat connective tissue. These connective tissue provides
cushions to the body from stress.Its area adjoining the epidermis is called as papillary region and
the deeper area is known as reticular dermis. Dermis is tightly connected to epidermis through a
basement membrane. Papillary layercomprising of mainly collagen, intewines with the rete
ridges of the epidermis. Reticular layer consists of irregular connective tissue fibers, densely
packed collagen, elantin and reticular fibers. Structurally, dermis comprises of collagen, elastic
fibers and fibrillar matrix. It also provides the sence of touch, heat etc..
What is a linked listWhat is a linked lists general syntaxCan .pdf
What is a linked list?
What is a linked lists general syntax?
Can you give me any tips on using linked lists or any extra general info I may need to know?
Solution
Linked Lists: It is a collection of data elements. A single linked list points to the next element of
the linked list. A double linked list points to both the previous and next elements.
For every node in the linked list, it has 2 parts - data and pointer
Unlike arrays, linked lists are not stored at continguous location. As compared to arrays, linked
lists offer dynamic size (we can add or delete elements from the linked list easily). A
disadvantage as compared to arrays being, random access of the element is not possible in a
linked list.
General Syntax in C:
//node
struct node
{
int data; // data element
struct node *next; // pointer to next element
}
Best way to learn linked lists is to implement the data structure along with some basic operations
on it: Inserting an element (at the start, at the end, at the middle), Deleting an element (from the
start, from the end, from the middle), Counting the number of elements etc..
What is the output of running class GenericMethodDemo of the followi.pdf
What is the output of running class GenericMethodDemo of the following code?
public class GenericMethodDemo {
public static void main(String[] args ) {
Integer[] integers = {1, 2, 3, 4, 5};
String[] strings = {\"London\", \"Paris\", \"Dhaka\",
\"Austin\", \"Sydney\"};
GenericMethodDemo.print(integers);
GenericMethodDemo.print(strings);
}
public static void print(E[] list) {
for (int i = 0; i < list.length; i++){
System.out.print(list[i] + \" \");
}
System.out.println();
}
}
What is the output of running class GenericMethodDemo of the following code?
public class GenericMethodDemo {
public static void main(String[] args ) {
Integer[] integers = {1, 2, 3, 4, 5};
String[] strings = {\"London\", \"Paris\", \"Dhaka\",
\"Austin\", \"Sydney\"};
GenericMethodDemo.print(integers);
GenericMethodDemo.print(strings);
}
public static void print(E[] list) {
for (int i = 0; i < list.length; i++){
System.out.print(list[i] + \" \");
}
System.out.println();
}
}
Solution
output 1 :
London
Paris
Dhaka
Austin
Sydney
The above is the output of hte above program.
What do you think are the roles of professional societies in contemp.pdf
What do you think are the roles of professional societies in contemporary engineering? Do you
expect to join a professional engineering society in the future?
Solution
Roles of professional societies in contemporary engineering:
Engineers have the very unique role for solving social problems using the skills and talent of
theirs.They solve the problems using devices, systems and machines.They are responsible for
connecting, supplying and protecting the society.
One of the key area considered is known as CONNECT. The engineers links communities
through transport infrastructure. The roads,railways and aircraft transport systems allow people
to travel from one end of globe to other.Also there are technologies like 3G, 4G which enables
faster communication with people without any physical transportation.So the Engineers are
responsible for connecting people over the globe.
The other strand is SUPPLY. The society is not only contributed but also sustained by
Water,Gas,Electricity and Sewage Infrastructure.These system are developed by the Engineers
which serves the basic needs of everyone.
Also another considering aspect is the Protection. There are so many ways in which the engineer
is directly or indirectly responsible for protection of the society.The Engineers are responsible
for designing the flood defense and military systems.They are also responsible for maintenance
of these systems.By inventing such system they become able to protect their country.
In addition to these, Engineers are responsible for shaping the future.Their efforts of saving the
information and utilizing it on required times has revolutionized the era.
Due to the above mentioned roles we can join professional engineering to better shape our
society..
More from bhim1213 (20)
In 1998, Congress passed legislation concerning shifting the burden .pdf
In 1998, Congress passed legislation concerning shifting the burden .pdf
If A denotes some event, what does A denote If P(A)equals=0.997, wh.pdf
If A denotes some event, what does A denote If P(A)equals=0.997, wh.pdf
How do neutrophils find and get to an infectionSolutionNeutro.pdf
How do neutrophils find and get to an infectionSolutionNeutro.pdf
How many times will the following code print Welcome to Java in.pdf
How many times will the following code print Welcome to Java in.pdf
From your own words not copy past from internet please Talked about.pdf
From your own words not copy past from internet please Talked about.pdf
Forms an important part of the subunits of the ribosome. The _ are sp.pdf
Forms an important part of the subunits of the ribosome. The _ are sp.pdf
During DNA replication, a series of steps are required to ensure tha.pdf
During DNA replication, a series of steps are required to ensure tha.pdf
Disease X occurs when someone has the xx genotype. However, only 20 .pdf
Disease X occurs when someone has the xx genotype. However, only 20 .pdf
Darwins Theory had five main tenets (or components), what are they.pdf
Darwins Theory had five main tenets (or components), what are they.pdf
Define toxic shock syndrome (TSS) impetigo MRSASolutionAnswer.pdf
Define toxic shock syndrome (TSS) impetigo MRSASolutionAnswer.pdf
A system was set up in parallel with two components, A and B. The pr.pdf
A system was set up in parallel with two components, A and B. The pr.pdf
All content is made permanent for future use. All content will be lo.pdf
All content is made permanent for future use. All content will be lo.pdf
a. A waitress is serving 5 people at a table. She has the 5 dishes t.pdf
a. A waitress is serving 5 people at a table. She has the 5 dishes t.pdf
Biochemistry homework Focus concept ripening fruit and the activity.pdf
Biochemistry homework Focus concept ripening fruit and the activity.pdf
A process that has its representative PCB in a device queue is in th.pdf
A process that has its representative PCB in a device queue is in th.pdf
Which of the following statements is (are) trueI Cash flow is a.pdf
Which of the following statements is (are) trueI Cash flow is a.pdf
What is the relationship of the epithelium of the epidermis to the co.pdf
What is the relationship of the epithelium of the epidermis to the co.pdf
What is a linked listWhat is a linked lists general syntaxCan .pdf
What is a linked listWhat is a linked lists general syntaxCan .pdf
What is the output of running class GenericMethodDemo of the followi.pdf
What is the output of running class GenericMethodDemo of the followi.pdf
What do you think are the roles of professional societies in contemp.pdf
What do you think are the roles of professional societies in contemp.pdf
Recently uploaded
Instructions for Submissions thorugh G- Classroom.pptx
This presentation provides a briefing on how to upload submissions and documents in Google Classroom. It was prepared as part of an orientation for new Sainik School in-service teacher trainees. As a training officer, my goal is to ensure that you are comfortable and proficient with this essential tool for managing assignments and fostering student engagement.
Chapter 3 - Islamic Banking Products and Services.pptx
Chapter 3 - Islamic Banking Products and Services.pptxMohd Adib Abd Muin, Senior Lecturer at Universiti Utara Malaysia
This slide is prepared for master's students (MIFB & MIBS) UUM. May it be useful to all.Welcome to TechSoup New Member Orientation and Q&A (May 2024).pdf
In this webinar you will learn how your organization can access TechSoup's wide variety of product discount and donation programs. From hardware to software, we'll give you a tour of the tools available to help your nonprofit with productivity, collaboration, financial management, donor tracking, security, and more.
Unit 2- Research Aptitude (UGC NET Paper I).pdf
This slide describes the research aptitude of unit 2 in the UGC NET paper I.
The geography of Taylor Swift - some ideas
Geographical themes connected with Taylor Swift's ERAS tour - coming to the UK in June 2024
Synthetic Fiber Construction in lab .pptx
Synthetic fiber production is a fascinating and complex field that blends chemistry, engineering, and environmental science. By understanding these aspects, students can gain a comprehensive view of synthetic fiber production, its impact on society and the environment, and the potential for future innovations. Synthetic fibers play a crucial role in modern society, impacting various aspects of daily life, industry, and the environment. ynthetic fibers are integral to modern life, offering a range of benefits from cost-effectiveness and versatility to innovative applications and performance characteristics. While they pose environmental challenges, ongoing research and development aim to create more sustainable and eco-friendly alternatives. Understanding the importance of synthetic fibers helps in appreciating their role in the economy, industry, and daily life, while also emphasizing the need for sustainable practices and innovation.
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH ANSWERS.
Thesis Statement for students diagnonsed withADHD.ppt
Presentation required for the master in Education.
The Roman Empire A Historical Colossus.pdf
The Roman Empire, a vast and enduring power, stands as one of history's most remarkable civilizations, leaving an indelible imprint on the world. It emerged from the Roman Republic, transitioning into an imperial powerhouse under the leadership of Augustus Caesar in 27 BCE. This transformation marked the beginning of an era defined by unprecedented territorial expansion, architectural marvels, and profound cultural influence.
The empire's roots lie in the city of Rome, founded, according to legend, by Romulus in 753 BCE. Over centuries, Rome evolved from a small settlement to a formidable republic, characterized by a complex political system with elected officials and checks on power. However, internal strife, class conflicts, and military ambitions paved the way for the end of the Republic. Julius Caesar’s dictatorship and subsequent assassination in 44 BCE created a power vacuum, leading to a civil war. Octavian, later Augustus, emerged victorious, heralding the Roman Empire’s birth.
Under Augustus, the empire experienced the Pax Romana, a 200-year period of relative peace and stability. Augustus reformed the military, established efficient administrative systems, and initiated grand construction projects. The empire's borders expanded, encompassing territories from Britain to Egypt and from Spain to the Euphrates. Roman legions, renowned for their discipline and engineering prowess, secured and maintained these vast territories, building roads, fortifications, and cities that facilitated control and integration.
The Roman Empire’s society was hierarchical, with a rigid class system. At the top were the patricians, wealthy elites who held significant political power. Below them were the plebeians, free citizens with limited political influence, and the vast numbers of slaves who formed the backbone of the economy. The family unit was central, governed by the paterfamilias, the male head who held absolute authority.
Culturally, the Romans were eclectic, absorbing and adapting elements from the civilizations they encountered, particularly the Greeks. Roman art, literature, and philosophy reflected this synthesis, creating a rich cultural tapestry. Latin, the Roman language, became the lingua franca of the Western world, influencing numerous modern languages.
Roman architecture and engineering achievements were monumental. They perfected the arch, vault, and dome, constructing enduring structures like the Colosseum, Pantheon, and aqueducts. These engineering marvels not only showcased Roman ingenuity but also served practical purposes, from public entertainment to water supply.
1.4 modern child centered education - mahatma gandhi-2.pptx
Child centred education is an educational approach that priorities the interest, needs and abilities of the child in the learning process.
Biological Screening of Herbal Drugs in detailed.
Biological screening of herbal drugs: Introduction and Need for
Phyto-Pharmacological Screening, New Strategies for evaluating
Natural Products, In vitro evaluation techniques for Antioxidants, Antimicrobial and Anticancer drugs. In vivo evaluation techniques
for Anti-inflammatory, Antiulcer, Anticancer, Wound healing, Antidiabetic, Hepatoprotective, Cardio protective, Diuretics and
Antifertility, Toxicity studies as per OECD guidelines
Supporting (UKRI) OA monographs at Salford.pptx
How libraries can support authors with open access requirements for UKRI funded books
Wednesday 22 May 2024, 14:00-15:00.
CLASS 11 CBSE B.St Project AIDS TO TRADE - INSURANCE
Class 11 CBSE Business Studies Project ( AIDS TO TRADE - INSURANCE)
Overview on Edible Vaccine: Pros & Cons with Mechanism
This ppt include the description of the edible vaccine i.e. a new concept over the traditional vaccine administered by injection.
Francesca Gottschalk - How can education support child empowerment.pptx
Francesca Gottschalk from the OECD’s Centre for Educational Research and Innovation presents at the Ask an Expert Webinar: How can education support child empowerment?
Operation Blue Star - Saka Neela Tara
Operation “Blue Star” is the only event in the history of Independent India where the state went into war with its own people. Even after about 40 years it is not clear if it was culmination of states anger over people of the region, a political game of power or start of dictatorial chapter in the democratic setup.
The people of Punjab felt alienated from main stream due to denial of their just demands during a long democratic struggle since independence. As it happen all over the word, it led to militant struggle with great loss of lives of military, police and civilian personnel. Killing of Indira Gandhi and massacre of innocent Sikhs in Delhi and other India cities was also associated with this movement.
A Strategic Approach: GenAI in Education
Artificial Intelligence (AI) technologies such as Generative AI, Image Generators and Large Language Models have had a dramatic impact on teaching, learning and assessment over the past 18 months. The most immediate threat AI posed was to Academic Integrity with Higher Education Institutes (HEIs) focusing their efforts on combating the use of GenAI in assessment. Guidelines were developed for staff and students, policies put in place too. Innovative educators have forged paths in the use of Generative AI for teaching, learning and assessments leading to pockets of transformation springing up across HEIs, often with little or no top-down guidance, support or direction.
This Gasta posits a strategic approach to integrating AI into HEIs to prepare staff, students and the curriculum for an evolving world and workplace. We will highlight the advantages of working with these technologies beyond the realm of teaching, learning and assessment by considering prompt engineering skills, industry impact, curriculum changes, and the need for staff upskilling. In contrast, not engaging strategically with Generative AI poses risks, including falling behind peers, missed opportunities and failing to ensure our graduates remain employable. The rapid evolution of AI technologies necessitates a proactive and strategic approach if we are to remain relevant.
Unit 8 - Information and Communication Technology (Paper I).pdf
This slides describes the basic concepts of ICT, basics of Email, Emerging Technology and Digital Initiatives in Education. This presentations aligns with the UGC Paper I syllabus.
Recently uploaded (20)
Instructions for Submissions thorugh G- Classroom.pptx
Instructions for Submissions thorugh G- Classroom.pptx
Chapter 3 - Islamic Banking Products and Services.pptx
Chapter 3 - Islamic Banking Products and Services.pptx
Welcome to TechSoup New Member Orientation and Q&A (May 2024).pdf
Welcome to TechSoup New Member Orientation and Q&A (May 2024).pdf
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
Thesis Statement for students diagnonsed withADHD.ppt
Thesis Statement for students diagnonsed withADHD.ppt
1.4 modern child centered education - mahatma gandhi-2.pptx
1.4 modern child centered education - mahatma gandhi-2.pptx
CLASS 11 CBSE B.St Project AIDS TO TRADE - INSURANCE
CLASS 11 CBSE B.St Project AIDS TO TRADE - INSURANCE
Overview on Edible Vaccine: Pros & Cons with Mechanism
Overview on Edible Vaccine: Pros & Cons with Mechanism
Francesca Gottschalk - How can education support child empowerment.pptx
Francesca Gottschalk - How can education support child empowerment.pptx
Unit 8 - Information and Communication Technology (Paper I).pdf
Unit 8 - Information and Communication Technology (Paper I).pdf
To create a node for a binary search tree (BTNode, ) and to create a .pdf
- 1. To create a node for a binary search tree (BTNode, ) and to create a binary search tree of comparable objects (Tree BTNode BTNode -data:E -left: BTNode -right: BTNode +BTNode (newData:E, newLeft: BTNode, newRight: BTNode) +getData():E +getLeft():BTNode +getRight():BTNode +getRightMostData():E +inOrderPrint():void +removeRightmost(): BTNode +setData(newData:E):void +setLeft(newleft: BTNode):void +setRight(newRight: BTNode):void needed for remove needed for remove Tree for Lab 7 Tree -root: 8TNode - numltems:int +Tree() +add(element:E):void +remove(element:E):boolean + remove +size():int + printTree():void Solution //BTNode.java public class BTNode { private E data; private BTNode left; private BTNode right; public BTNode(E newData, BTNode newLeft, BTNode newRight) { data = newData; left = newLeft; right = newRight; }//end constructor /** * Returns the data * @return The data */ public E getData() { return data; }//end getData /**
- 2. * Returns the left link * @return the left link */ public BTNode getLeft() { return left; }//end getLeft /** * Returns the right link * @return the right link */ public BTNode getRight() { return right; }//end getRight /** * Prints the tree in order from left to right. */ public void inOrderPrint() { if (left != null){ left.inOrderPrint(); }//end left System.out.println(data); if(right != null){ right.inOrderPrint(); }//end right }//end inOrderPrint /** * Sets the data in the node
- 3. * @param newData The new data to be passed */ public void setData(E newData) { data = newData; }//end setData /** * Sets a new link to left * @param newLeft the new link to go left */ public void setLeft(BTNode newLeft) { left = newLeft; }//end setLeft /** * Sets a new link to the right * @param newRight the new link to the right */ public void setRight(BTNode newRight) { right = newRight; }//end setRight public E getRightMostData() { if(right == null){ return data; } else { return right.getRightMostData(); }//end right == null if-else }//end getRightMostData public BTNode removeRightmost() {
- 4. if (right == null){ return left; } else { right = right.removeRightmost(); return this; }//end if right == null if=-else }//end removeRightMost }//end BTNode ===================================================================== == //Tree.java public class Tree> { private BTNode root; private int numItems; /** * No-arg constructor */ public Tree() { root = null; numItems = 0; }//end constructor public void add(E element) { if (root == null) { root = new BTNode(element, null, null); }else{ BTNode cursor = root; boolean done = false; while(!done){ if (element.compareTo(cursor.getData()) <= 0){//cursor.getData().compareTo(element) > 0){
- 5. if (cursor.getLeft() == null) { cursor.setLeft(new BTNode(element,null,null)); done = true; } else { cursor = cursor.getLeft(); } //end left is null if-else }else{ if(cursor.getRight() == null){ cursor.setRight(new BTNode(element, null, null)); done = true; }else{ cursor = cursor.getRight(); }//end cursor.getRight if-else }//end compareto if-else }//end while }//end root ==null if-else numItems++; }//end add /** * Get the number of elements in the tree * @return The size of the tree */ public int size() { return numItems; }//end size /** * Print the tree in order */ public void printTree() { if (root == null){ System.out.println("This tree is empty"); }else{
- 6. root.inOrderPrint(); }//end if-else }//end inOrderPrint public boolean remove(E target) { BTNode cursor = root; BTNode parentOfCursor = null; boolean found = false; while (cursor != null && !found){ if (target.equals(cursor.getData())){ found = true; }else{ if(target.compareTo(cursor.getData()) <= 0){ parentOfCursor = cursor; cursor = cursor.getLeft(); }else{ parentOfCursor = cursor; cursor = cursor.getRight(); }//end target.compareTo if-else }//end target.equals if-else }//end cursor && found while if (cursor != null){ if (cursor.getLeft() == null && cursor == root){ root = root.getRight(); } else if (cursor.getLeft() == null && cursor!= root){ if (cursor == parentOfCursor.getLeft()){ parentOfCursor.setLeft(cursor.getRight()); } else { parentOfCursor.setRight(cursor.getRight()); }//end cursor ==parentOfCursor.setLEft if-else } else{ cursor.setData(cursor.getLeft().getRightMostData()); cursor.setLeft(cursor.getLeft().removeRightmost());
- 7. } //end cursor == root if-else }//end found if return found; } }//end Tree