#include <iostream>
#include <queue>
#include <stack>

using namespace std;

class Node {
    public:
        int data;
        Node *left;
        Node *right;
        Node(int d) {
            data = d; 
            left = nullptr; 
            right = nullptr;
        }
}

// create a binary tree
auto root = new Node(1), n2 = new Node(2), n3 = new Node(3), 
    n4 = new Node(4), n5 = new Node(5);
root->left = n2;
root->right = n3;
n2->left = n4;
n3->right = n5;

void inorder(Node * p) {
    if (p != nullptr) {
        inorder(p->left);
        cout << p->data << " ";
        inorder(p->right);        
    }
}

inorder(root)

void preorder(Node * p) {
    if (p != nullptr) {
        cout << p->data << " ";
        preorder(p->left);        
        preorder(p->right);        
    }
}

preorder(root)

// create a non-recursive version
// which data structure should we use?
void preorder_nr(Node * p) {
    
}

// not recursive
void preorder_nr(Node * p) {
    stack<Node *> s;
    s.push(p);
    while (!s.empty()) {
        Node * node = s.top();
        s.pop();
        if (node != nullptr) {
            cout << node->data << " ";
            s.push(node->right);
            s.push(node->left);
        }
    }
}

preorder_nr(root)

void postorder(Node * p) {
    if (p != nullptr) {
        postorder(p->left);        
        postorder(p->right);        
        cout << p->data << " ";
    }
}

postorder(root)

void breadthfirst(Node * p) {
    // Define q here. What type does it need to be?
    auto q = queue<Node *>();
    q.push(p); // Push the root
    while(!q.empty()) {
        Node *v = q.front();  
        q.pop();
        if (v != nullptr) {
            cout << v->data << " ";
            q.push(v->left);  
            q.push(v->right);  
        }
    }
}

breadthfirst(root)

int countLeafNodes(Node * r) {

}

countLeafNodes(root)

int countLeafNodes(Node *r) {
    if (r == nullptr) return 0;
    if(r->left == nullptr && r->right == nullptr) return 1;
    int leftLeaves = countLeafNodes(r->left);
    int rightLeaves = countLeafNodes(r->right);
    return leftLeaves + rightLeaves;
}

countLeafNodes(root)

void shallowCopyTree(Node* &copiedTreeRoot, Node* otherTreeRoot)
{
    if(otherTreeRoot == nullptr) copiedTreeRoot = nullptr;  
    else {
        copiedTreeRoot = new Node(otherTreeRoot->data);
        copiedTreeRoot->left = otherTreeRoot->left;
        copiedTreeRoot->right = otherTreeRoot->right;
    }
}

Node * rootShallowCopy = nullptr;
shallowCopyTree(rootShallowCopy, root);
inorder(rootShallowCopy)

root->left->data = 20;
inorder(rootShallowCopy)

void deepCopyTree(Node* &copiedTreeRoot, Node* otherTreeRoot)
{
    if(otherTreeRoot == nullptr) copiedTreeRoot = nullptr;  
    else {
        copiedTreeRoot = new Node(otherTreeRoot->data);  
        deepCopyTree(copiedTreeRoot->left, otherTreeRoot->left);  
        deepCopyTree(copiedTreeRoot->right, otherTreeRoot->right); 
    }
}

Node * rootDeepCopy = nullptr;
deepCopyTree(rootDeepCopy, root);
inorder(rootDeepCopy)

root->left->data = 200;
inorder(rootDeepCopy)