-
Short Answers
Section 10.4
Tree
Traversals
9. Using the binary_tree_node from Section 10.3, Write a
recursive function to meet the following specification. You do not
need to check the precondition.
template <class Item>
void increase(binary_tree_node<Item>* root_ptr)
// Precondition: root_ptr is the root pointer of a binary tree.
// Postcondition: Every node of the tree has had its data increased by one.
10. Using the binary_tree_node from Section 10.3, write a
recursive function to meet the following specification. You do not...
-
Implement the function for the prototype below. Document
your code. You do not have access to authors helper functions, only
the binary_tree_node class.
template size_t count(binary_tree_node * root_ptr, Item
value)
// Precondition: root_ptr is the root pointer of a
binary tree (which may be empty).
// Postcondition: The number of nodes that contain value
in the tree is returned.
-
Class SortedList
{
Public:
SortedType();
int getLength(); //returns size of the list
void putItem(Itemtype item); //inserts an
item
Itemtype getNextItem(); //returns the next item pointed
by the index
void deleteItem(Itemtype item) //deletes a specified
item
Private:
int length; //length of the list
Nodetype* listData //head of the list
Nodetype* currentPos; //current pointer to the
list
}
Class Itemtype
{
Public:
Itemtype();
int getValue();// returns the value
Private:
int value;
}
struct Nodetype
{
Itemtype info;
Nodetype* next;
}
Add a...
-
C++.
Test if a Tree is Balanced
Use the given Tree class and implement a function to test if the
binary tree is balanced or not.
An empty tree is height-balanced. A non-empty binary tree T is
balanced if:
1) Left subtree of T is balanced
2) Right subtree of T is balanced
3) The difference between heights of left subtree and right
subtree is not more than 1.
#include <iostream>
using namespace std;
template<class ItemType>
class Tree {
private:...
-
C++. Test if a Tree is Balanced Use the given Tree class and
implement a function to test if the binary tree is balanced or not.
An empty tree is height-balanced. A non-empty binary tree T is
balanced if:
1) Left subtree of T is balanced
2) Right subtree of T is balanced
3) The difference between heights of left subtree and right
subtree is not more than 1.
Please MAKE SURE TO CLEARLY SHOW THE CODING. AND YOUR
OUTPUT....
-
Write a function, swapSubtrees, that swaps all of the left and
right subtrees of a binary tree. Add this function to the class
binaryTreeType and create a program to test this function.
#include <iostream>
using namespace std;
//Definition of the Node
template <class elemType>
struct nodeType
{
elemType info;
nodeType<elemType> *lLink;
nodeType<elemType> *rLink;
};
//Definition of the class
template <class elemType>
class binaryTreeType
{
public:
//Overload the assignment operator.
const binaryTreeType<elemType>& operator=(const
binaryTreeType<elemType>&)
{
if (this != &otherTree) //avoid self-copy...
-
Please use the linked approach implement the BST ADT,
implement all the functions in the BSTree.cpp. Add the ouput of the
implementation.
use recursive functions to traverse the tree - read the
implementation notes on using helper functions.
Please use C++ programming
//////////////////////////////////////////////////////////////
#include "BSTree.h"
template <typename DataType, class KeyType>
BSTree<DataType, KeyType>::BSTreeNode::BSTreeNode ( const
DataType &nodeDataItem, BSTreeNode *leftPtr, BSTreeNode
*rightPtr )
{
}
template < typename DataType, class KeyType >
BSTree<DataType, KeyType>::BSTree ()
{
root = 0;
}
template...
-
Requirements
Print a range
Write a bag member function with two parameters. The two
parameters are Items x and y. The function should write to the
console all Items in the bag that are between the first occurrence
of x and the first occurrence of y. You may assume that items can
be compared for equality using ==.
Use the following header for the function:
void print_value_range(const Item& x, const Item&
y);
print_value_range can be interpreted in a number of...
-
Write a C++ program to validate computer user-ids and passwords.
A list of valid ids and passwords (unsorted) is read from a file
and stored in a Binary Search Tree (BST) of UserInfo objects. When
user-ids and passwords are entered during execution, this BST is
searched to determine whether they are legal. Input (file):
UserInfo records for valid users Input (keyboard): Ids and
passwords of users logging in Output (screen): Messages indicating
whether user-ids and passwords are valid, as well...
-
For this computer assignment, you are to write a C++ program to
implement a class for binary trees. To deal with variety of data
types, implement this class as a template.
The definition of the class for a binary tree (as a template) is
given as follows:
template < class T > class binTree {
public:
binTree ( ); // default constructor
unsigned height ( ) const; // returns height of tree
virtual void insert ( const T& ); //...
Please use the linked approach implement the BST ADT,
implement all the functions in the BSTree.cpp. Add the ouput of the
implementation.
use recursive functions to traverse the tree - read the
implementation notes on using helper functions.
Please use C++ programming
//////////////////////////////////////////////////////////////
#include "BSTree.h"
template <typename DataType, class KeyType>
BSTree<DataType, KeyType>::BSTreeNode::BSTreeNode ( const
DataType &nodeDataItem, BSTreeNode *leftPtr, BSTreeNode
*rightPtr )
{
}
template < typename DataType, class KeyType >
BSTree<DataType, KeyType>::BSTree ()
{
root = 0;
}
template...