The definition for binary search tree should be the one used in class Suggested-book definition: A BST is a binary tree that (if not empty) also follows two storage rules regarding its nodes’ items: ♯ For any node n of the tree, every item in n’s left subtree (LST), if not empty, is less than or equal the item in n ♯ For any node n of the tree, every item in n’s right subtree (RST), if not empty, is greater than the item in n bst_insert must be iterative (NOT recursive). ● bst_remove and bst_remove_max must use the algorithm described by the suggested book authors
The definition for binary search tree should be the one used in class Suggested-book definition: A BST is a binary tree that (if not empty) also follows two storage rules regarding its nodes’ items: ♯ For any node n of the tree, every item in n’s left subtree (LST), if not empty, is less than or equal the item in n ♯ For any node n of the tree, every item in n’s right subtree (RST), if not empty, is greater than the item in n bst_insert must be iterative (NOT recursive). ● bst_remove and bst_remove_max must use the algorithm described by the suggested book authors
Related questions
Question
The definition for binary search tree should be the one used in class
| Suggested-book definition: |
| A BST is a binary tree that (if not empty) also follows two storage rules regarding its nodes’ items: |
| ♯ | For any node n of the tree, every item in n’s left subtree (LST), if not empty, is less than or equal the item in n |
| ♯ | For any node n of the tree, every item in n’s right subtree (RST), if not empty, is greater than the item in n |
| bst_insert must be iterative (NOT recursive). |
| ● | bst_remove and bst_remove_max must use the algorithm described by the suggested book authors |
![[*]btNode.h X
12345678981234567898122342525278293812345拓劲89812BU456F8498152够弘556刃8 59 =
10
ddddddd□ENN~~~ ~ ~ NO
20
30
40
च च च
50
#ifndef BT_NODE_H
#define BT_NODE_H
struct btNode
{
};
// pre:
int data;
btNode* left;
btNode* right;
// post: The binary search tree has been traversed in-order and the data
values are written (as they are encountered) to portArray in
increasing positional order starting from the first element
portToArrayInOrder (btNode* bst_root, int* portArray);
portToArrayInOrder
Aux (btNode* bst_root, int* portArray, int& portIndex);
void
void
//
// pre: (none)
// post: dynamic memory of all the nodes of the tree rooted at root has been
freed up (returned back to heap/freestore) and the tree is now empty
(root pointer contains the null address)
void tree_clear (btNode*& root);
// pre: (none)
// post: # of nodes contained in tree rooted at root is returned
int bst_size(btNode* bst_root);
//
// pre:
//
bst_root is root pointer of a binary search tree (may be 0 for
empty tree) and portArray has the base address of an array Large
enough to hold all the data items in the binary search tree
bst_root is root pointer of a binary search tree (may be for
empty tree)
If no node in the binary search tree has data equals insInt, a
node with data insInt has been created and inserted at the proper
Location in the tree to maintain binary search tree property.
If a node with data equals insInt is found, the node's data field
has been overwritten with insInt; no new node has been created.
(Latter case seems odd but it's to mimick update of key-associated
data that exists in more general/real-world situations.)
write prototype for bst_insert here
bst_root is root pointer of a binary search tree (may be for
empty tree)
If remInt was in the tree, then remInt has been removed, bst_root
now points to the root of the new (smaller) binary search tree,
and the function returns true. Otherwise, if remInt was not in the
tree, then the tree is unchanged, and the function returns false.
post:
// pre:
// post:
// write prototype for bst_remove here
// pre:
// post:
60 #endif
bst_root is root pointer of a non-empty binary search tree
The Largest item in the binary search tree has been removed, and
bst_root now points to the root of the new (smaller) binary search
tree. The reference parameter, removed, has been set to a copy of
the removed item.
// write prototype for bst_remove_max here](/v2/_next/image?url=https%3A%2F%2Fcontent.bartleby.com%2Fqna-images%2Fquestion%2Fb51b654d-3a22-424d-90a5-d3d04b635cc6%2Fbfe26ff0-035d-49ab-9d28-a454d7fcbc85%2Fn3qgg5d_processed.png&w=3840&q=75)
Transcribed Image Text:[*]btNode.h X
12345678981234567898122342525278293812345拓劲89812BU456F8498152够弘556刃8 59 =
10
ddddddd□ENN~~~ ~ ~ NO
20
30
40
च च च
50
#ifndef BT_NODE_H
#define BT_NODE_H
struct btNode
{
};
// pre:
int data;
btNode* left;
btNode* right;
// post: The binary search tree has been traversed in-order and the data
values are written (as they are encountered) to portArray in
increasing positional order starting from the first element
portToArrayInOrder (btNode* bst_root, int* portArray);
portToArrayInOrder
Aux (btNode* bst_root, int* portArray, int& portIndex);
void
void
//
// pre: (none)
// post: dynamic memory of all the nodes of the tree rooted at root has been
freed up (returned back to heap/freestore) and the tree is now empty
(root pointer contains the null address)
void tree_clear (btNode*& root);
// pre: (none)
// post: # of nodes contained in tree rooted at root is returned
int bst_size(btNode* bst_root);
//
// pre:
//
bst_root is root pointer of a binary search tree (may be 0 for
empty tree) and portArray has the base address of an array Large
enough to hold all the data items in the binary search tree
bst_root is root pointer of a binary search tree (may be for
empty tree)
If no node in the binary search tree has data equals insInt, a
node with data insInt has been created and inserted at the proper
Location in the tree to maintain binary search tree property.
If a node with data equals insInt is found, the node's data field
has been overwritten with insInt; no new node has been created.
(Latter case seems odd but it's to mimick update of key-associated
data that exists in more general/real-world situations.)
write prototype for bst_insert here
bst_root is root pointer of a binary search tree (may be for
empty tree)
If remInt was in the tree, then remInt has been removed, bst_root
now points to the root of the new (smaller) binary search tree,
and the function returns true. Otherwise, if remInt was not in the
tree, then the tree is unchanged, and the function returns false.
post:
// pre:
// post:
// write prototype for bst_remove here
// pre:
// post:
60 #endif
bst_root is root pointer of a non-empty binary search tree
The Largest item in the binary search tree has been removed, and
bst_root now points to the root of the new (smaller) binary search
tree. The reference parameter, removed, has been set to a copy of
the removed item.
// write prototype for bst_remove_max here
![1
Hamin A GỌNng
2
3
// write definition for bst_insert here
// write definition for bst_remove here
7 // write definition for bst_remove_max here
4
5
6
8
9
10 void portToArrayInOrder (btNode* bst_root, int* portArray)
11 {
12
13
14
15 }
16
17
18
19
20
21
22
23
24
25
22
#include "btNode.h"
26
27
28
29
30
31
32
33
34
35
36
37
38
39
if (bst_root == 0) return;
int portIndex = 0;
portToArrayInOrderAux (bst_root, portArray, portIndex);
void portToArrayInOrderAux (btNode* bst_root, int* portArray, int& portIndex)
{
if (bst_root == 0) return;
portToArrayInOrderAux (bst_root->left, portArray, portIndex);
portArray[port Index++] = bst_root->data;
portToArrayInOrderAux(bst_root->right, portArray, portIndex);
void tree_clear (btNode* & root)
{
if (root == 0) return;
tree_clear (root->left);
tree_clear (root->right);
delete root;
root = 0;
int bst_size(btNode* bst_root)
{
if (bst_root == 0) return 0;
return 1 + bst_size(bst_root->left) + bst_size(bst_root->right);](/v2/_next/image?url=https%3A%2F%2Fcontent.bartleby.com%2Fqna-images%2Fquestion%2Fb51b654d-3a22-424d-90a5-d3d04b635cc6%2Fbfe26ff0-035d-49ab-9d28-a454d7fcbc85%2Fdla9iv_processed.png&w=3840&q=75)
Transcribed Image Text:1
Hamin A GỌNng
2
3
// write definition for bst_insert here
// write definition for bst_remove here
7 // write definition for bst_remove_max here
4
5
6
8
9
10 void portToArrayInOrder (btNode* bst_root, int* portArray)
11 {
12
13
14
15 }
16
17
18
19
20
21
22
23
24
25
22
#include "btNode.h"
26
27
28
29
30
31
32
33
34
35
36
37
38
39
if (bst_root == 0) return;
int portIndex = 0;
portToArrayInOrderAux (bst_root, portArray, portIndex);
void portToArrayInOrderAux (btNode* bst_root, int* portArray, int& portIndex)
{
if (bst_root == 0) return;
portToArrayInOrderAux (bst_root->left, portArray, portIndex);
portArray[port Index++] = bst_root->data;
portToArrayInOrderAux(bst_root->right, portArray, portIndex);
void tree_clear (btNode* & root)
{
if (root == 0) return;
tree_clear (root->left);
tree_clear (root->right);
delete root;
root = 0;
int bst_size(btNode* bst_root)
{
if (bst_root == 0) return 0;
return 1 + bst_size(bst_root->left) + bst_size(bst_root->right);
Expert Solution
This question has been solved!
Explore an expertly crafted, step-by-step solution for a thorough understanding of key concepts.
Step by step
Solved in 3 steps
