Question

Here you'll write the inorder traversal function in the header file "bst.h". Notice that the public inorder function calls a private recursive function _ inorder to do the actual traversal. This public-private strategy is the correct way to implement recursive functions, where the public function kicks off the recursion and the private function does the actual work. The public function is written for you, your job is to implement the private _ inorder function.

he main program has been written to input a sequence of integers and build a binary search tree, which you can then output. The input sequence is followed by a negative sentinel. Here's an example program run:

50
25
88
10
40
999
-1

Size: 6
Inorder: 10 25 40 50 88 999

Your job is to produce that last line of output, the inorder traversal of the tree with output to cout.

main.cpp is a read only file

#include <iostream>
#include "bst.h"

using namespace std;

int main()
{
binarysearchtree<int> tree;
int key;

//
// 1. Inputs values from the keyboard and builds a binary search tree;
// reads input until the sentinel (a negative value) is input. The
// resulting binary search tree is returned.
//
cin >> key;

while (key >= 0)
{
tree.insert(key);

cin >> key;
}

//
// 2. Output size and contents (in order):
//
cout << "Size: " << tree.size() << endl;
tree.inorder();

// done:
return 0;
}

bsh.h is the file to work on.

/*bsh.h*/

//
// Binary search tree
//

#pragma once

#include <iostream>

using namespace std;

template<typename TKey>
class binarysearchtree
{
private:
struct NODE
{
TKey Key;
NODE* Left;
NODE* Right;
};

NODE* Root; // pointer to root node of tree (nullptr if empty)
int Size; // # of nodes in the tree (0 if empty)
  
//
// _inorder does the actual inorder traversal and output
// to console. Each key is output to the console followed
// by " ", including the last key.
//
void _inorder(NODE* cur)
{
//
// TODO:
//
}

public:
//
// default constructor:
//
// Creates an empty tree.
//
binarysearchtree()
{
Root = nullptr;
Size = 0;
}

//
// size:
//
// Returns the # of nodes in the tree, 0 if empty.
//
int size()
{
return Size;
}
  
//
// inorder:
//
// Performs an inorder traversal of the tree, outputting
// the keys to the console.
//
void inorder()
{
cout << "Inorder: ";

_inorder(Root);

cout << endl;
}
};

Answer 1

void _inorder(Node* cur)
{
if (cur == NULL)
return;
  
_inorder(cur->left);
  
cout << cur->data << " ";
  
_inorder(cur->right);
}

This is a recursice solution for inorder traversal of a tree.

It will go to the leftmost node then print that and then its right node and then backtrack.

Try to understand the recursion behind the code.

First dry run the code with sample input.