Question

In C++ Given a pointer to the root of a binary search tree (has left, right, and parent pointers as well as a data section ) write a function (or functions) which will return an STL list (you should not define this class, it’s already included) with all of the values from the tree in sorted order. Your code should run in theta(N) time.

for the second part,.given a pointer to the first node of a linked list, you are asked to reverse the list. Explain, in English, not code, how you would complete such a task if you had a limited amount of memory (not enough to store the whole list twice!)

for the third part, given a binary search tree of ints, in which each node contains a size parameter (also an int), explain, in English, not code, how you would find the median element of the tree in theta(log N) time

Answer 1

Part 1:

C++ code:

// Header fies section
#include <iostream>
#include <string>
#include <list> // for STL list
using namespace std;

// TreeNode structure including left, right, and parent pointers as well as a data
struct TreeNode
{
    int data;
    TreeNode* left;
    TreeNode* right;
    TreeNode* parent;
};

// BinarySearchTree class declaration
class BinarySearchTree
{
public:
    // constructor
    BinarySearchTree();

    // function to insert the given key
    void insert(int key);

    // functions to print the tree
    void printPreorder();
    void printInorder();  
    void printPostorder();

    // function to make an ordered list from the tree
    list<int> makeOrderedList();

private:  
    // data field for the root of the tree
    TreeNode *root;

    // helper functions as private
    TreeNode* insertHelper(TreeNode *node, int key);
    void printPreorderHelper(TreeNode* node);
    void printInorderHelper(TreeNode* node);
    void printPostorderHelper(TreeNode *node);
    void makeOrderedListHelper(TreeNode* node, list<int> &result);
};

// default constructor sets the root to NULL
BinarySearchTree::BinarySearchTree()
{
    root = NULL;
}

// insert function inserts a new TreeNode in the tree
void BinarySearchTree::insert(int key)
{
    root = insertHelper(root, key);
}

// insertHelper function implementation
TreeNode* BinarySearchTree::insertHelper(TreeNode* node, int key)
{
    // if the node is NULL, create and return a new node
    if (node == NULL)
    {
        TreeNode* newNode = new TreeNode;
        newNode->data = key;
        newNode->left = NULL;
        newNode->right = NULL;
        newNode->parent = NULL;

        return newNode;
    }

    if (key < node->data)
    {
        // if the key is less than the node's data
        // insert the new node as the left node
        TreeNode* leftChild = insertHelper(node->left, key);
        node->left = leftChild;

        // set the parent of the left node
        leftChild->parent = node;
    }
    else if (key > node->data)
    {
        // if the key is greater than the node's data
        // insert the new node as the right node
        TreeNode* rightChild = insertHelper(node->right, key);
        node->right = rightChild;

        // set the parent of the right node
        rightChild->parent = node;
    }
    else
    {
        // do not allow the duplicates
    }

    // return the current node pointer
    return node;
}

// printPreorder function prints the tree elements using preorder traversal
void BinarySearchTree::printPreorder()
{
    printPreorderHelper(root);
}

// printPreorderHelper function implementation
void BinarySearchTree::printPreorderHelper(TreeNode* node)
{
    if (node != NULL)
    {
        // print the data of current node
        cout << node->data << " ";

        // go to left node
        printPreorderHelper(node->left);

        // go to right node
        printPreorderHelper(node->right);
    }
}

// printInorder function prints the tree elements using inorder traversal
void BinarySearchTree::printInorder()
{
    printInorderHelper(root);
}

// printInorderHelper function implementation
void BinarySearchTree::printInorderHelper(TreeNode* node)
{
    if (node != NULL)
    {
        // go to left node
        printInorderHelper(node->left);

        // print the data of current node
        cout << node->data << " ";

        // go to right node
        printInorderHelper(node->right);
    }
}

// printPostorder function prints the tree elements using inorder traversal
void BinarySearchTree::printPostorder()
{
    printPostorderHelper(root);
}

// printPostorderHelper function implementation
void BinarySearchTree::printPostorderHelper(TreeNode* node)
{
    if (node != NULL)
    {
        // go to left node
        printPostorderHelper(node->left);      

        // go to right node
        printPostorderHelper(node->right);

        // print the data of current node
        cout << node->data << " ";
    }
}

// makeOrderedList function returns an STL list with all of the values from the tree in sorted order
list<int> BinarySearchTree::makeOrderedList()
{
    list<int> result;

    makeOrderedListHelper(root, result);

    return result;
}

// makeOrderedListHelper function implementation
void BinarySearchTree::makeOrderedListHelper(TreeNode* node, list<int> &result)
{
    if (node != NULL)
    {
        // go to left node
        makeOrderedListHelper(node->left, result);

        result.push_back(node->data);

        // go to right node
        makeOrderedListHelper(node->right, result);
    }
}

// start main function
int main()
{
    // delcare a variable for the root of TreeNode
    BinarySearchTree bst;

    bst.insert(55);
    bst.insert(33);
    bst.insert(77);
    bst.insert(22);
    bst.insert(88);
    bst.insert(44);
    bst.insert(66);

    // print the tree using preorder traversal
    cout << "Preorder traversal of BST: ";
    bst.printPreorder();

    // print the tree using inorder traversal
    cout << "\nInorder traversal of BST:   ";
    bst.printInorder();

    // print the tree using postorder traversal
    cout << "\nPostorder traversal of BST: ";
    bst.printPostorder();

    // call the makeOrderedList function
    list<int> result = bst.makeOrderedList();
   
    // print the elements stored in the list
    cout << "\n\nElements stored in the list: ";
    for (auto itr = result.begin(); itr != result.end(); itr++)
    {
        cout << *itr << " ";
    }
    cout << endl;

    return 0;
} // end of main function

Sample Output:

Part 2:

Part 3: