#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)
4 2 1 3 5
void preorder(Node * p) {
if (p != nullptr) {
cout << p->data << " ";
preorder(p->left);
preorder(p->right);
}
}
preorder(root)
1 2 4 3 5
// 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)
1 2 4 3 5
void postorder(Node * p) {
if (p != nullptr) {
postorder(p->left);
postorder(p->right);
cout << p->data << " ";
}
}
postorder(root)
4 2 5 3 1
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)
1 2 3 4 5
int countLeafNodes(Node * r) {
}
countLeafNodes(root)
2
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)
4 2 1 3 5
root->left->data = 20;
inorder(rootShallowCopy)
4 20 1 3 5
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)
4 20 1 3 5
root->left->data = 200;
inorder(rootDeepCopy)
4 20 1 3 5