C++ function to populate right side of a tree - c++

Question

The Problem
We have provided you a class TreeNode. The methods are declared in TreeNode.h, and there are implementations of most of them in TreeNode.cpp.
Your work:
Implement the function TreeNode *makeFullRight(int n) that builds a full tree with
n
nodes. The way you will build the tree is that the left child of each two-child node will be a leaf. The nodes should be numbered (by populating its data_ field) from 1 to
n
, according to the following rule: if a node had number
i
, then any left child would have number
i
+
1
and any right child would have number
i
+
2
.
Put your code in TreeNode.cpp.
As an example, makeFullRight(7) will produce the tree
1
/ \
2 3
/ \
4 5
/ \
6 7
You should assume that your makeFullRight function will be given an odd number as input.
You can write this using any technique you want, but we recommend using recursion and writing a helper function.
Sample Run
Your main.cpp will exercise your code.
Ive tired to do it using recursion but i couldnt get the answer and now i am lost on how to the makeFullRight function
TreeNode.cpp- File
#include "TreeNode.h"
// Your function here
TreeNode *makeFullRight(int n)
{
}
// Methods and functions we provide following.
// You should not need to edit this code.
TreeNode::TreeNode(int data, TreeNode *left, TreeNode *right) :
data_(data), left_(left), right_(right) {}
TreeNode::~TreeNode() {
if (left_ != NULL)
delete left_;
if (right_ != NULL)
delete right_;
}
bool equal(TreeNode *n1, TreeNode *n2) {
if (n1 == NULL)
return n2 == NULL;
if (n2==NULL)
return false;
return (n1->getData() == n2->getData() &&
equal(n1->getLeft(),n2->getLeft()) &&
equal(n1->getRight(),n2->getRight()));
}
int TreeNode::getData() const {
return data_;
}
TreeNode *TreeNode::getLeft() const {
return left_;
}
TreeNode *TreeNode::getRight() const {
return right_;
}
TreeNode.h--- New File
#ifndef _TREENODE_H
#define _TREENODE_H
#include <cstddef>
class TreeNode {
public:
int data_;
TreeNode *left_;
TreeNode *right_;
TreeNode(int data=0, TreeNode *left=NULL, TreeNode *right=NULL);
~TreeNode();
int findMax() const;
int getData() const;
TreeNode *getLeft() const;
TreeNode *getRight() const;
};
// Here is the signature of the code you will write
TreeNode *makeFullRight(int n);
bool equal(TreeNode *n1, TreeNode *n2);
#endif
main.cpp ---New File
#include <iostream>
#include "TreeNode.h"
using namespace std;
const string RED_TEXT = "\033[1;31m";
const string GREEN_TEXT = "\033[1;32m";
const string RESET_TEXT = "\033[0m";
void print_pass(string message) {
cout<<GREEN_TEXT<<"TEST PASSED"<<RESET_TEXT<<": "<<message<<endl;
}
void print_fail(string message) {
cout<<RED_TEXT<<"TEST FAILED"<<RESET_TEXT<<": "<<message<<endl;
exit(1);
}
int main() {
TreeNode *example =
new TreeNode(1,
new TreeNode(2),
new TreeNode(3,
new TreeNode(4),
new TreeNode(5,
new TreeNode(6),
new TreeNode(7))));
// Try complete
TreeNode *x = makeFullRight(7);
cout << "Result of makeFullRight: " << endl;
if (equal(x,example))
print_pass("");
else
print_fail("");
// Clean up
delete x;
delete example;
}
Makefile---New File
EXENAME = main
OBJS = main.o TreeNode.o
CXX = clang++
CXXFLAGS = -std=c++0x -c -g -O0 -Wall -Wextra
LD = clang++
LDFLAGS = -std=c++0x
all: $(EXENAME)
$(EXENAME): $(OBJS)
$(LD) $^ $(LDFLAGS) -o $#
main.o: main.cpp
$(CXX) $< $(CXXFLAGS)
TreeNode.o: TreeNode.cpp TreeNode.h
$(CXX) $< $(CXXFLAGS)
clean:
-rm -f *.o $(EXENAME)

Answer 1

If you examine the tree, you will see that each subtree has k in the root, a leaf with k+1 in the left node, and a right-full tree with k+2 in its root in the right node.
Assume that you have the suggested helper function – let's call it "fullHelper" – that keeps track of the "current value" and produces a tree with that in its root:
// Produce a right-full tree with 'current' at the root, up until 'n'.
TreeNode* fullHelper(int n, int current);
Then you can write
TreeNode* makeFullRight(int n)
{
return fullHelper(n, 1);
}
Now, "all" you need is to write the helper function.
You need a base case and a recursive case:
If n == current, create a single node with n,
Otherwise, create a tree with current in the root, current+1 in the left leaf, and a right-full tree rooted at current+2 as its right subtree.
Translated to C++:
TreeNode* fullHelper(int n, int current)
{
return n == current
? new TreeNode(current)
: new TreeNode(current,
new TreeNode(current+1),
fullHelper(n, current+2));
}