// Tree traversal in C

#include <stdio.h>
#include <stdlib.h>

struct node {
int item;
struct node* left;
struct node* right;
};

// Inorder traversal
void inorderTraversal(struct node* root) {
if (root == NULL) return;
inorderTraversal(root->left);
printf("%d ->", root->item);
inorderTraversal(root->right);
}

// Preorder traversal
void preorderTraversal(struct node* root) {
if (root == NULL) return;
printf("%d ->", root->item);
preorderTraversal(root->left);
preorderTraversal(root->right);
}

// Postorder traversal
void postorderTraversal(struct node* root) {
if (root == NULL) return;
postorderTraversal(root->left);
postorderTraversal(root->right);
printf("%d ->", root->item);
}

// Create a new Node

struct node* createNode(value) {
struct node* newNode = malloc(sizeof(struct node));
newNode->item = value;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
}

// Insert on the left of the node

struct node* insertLeft(struct node* root, int value) {
root->left = createNode(value);
return root->left;
}

// Insert on the right of the node

struct node* insertRight(struct node* root, int value) {
root->right = createNode(value);
return root->right;
}

int main() {
struct node* root = createNode(1);
insertLeft(root, 2);
insertRight(root, 3);
insertLeft(root->left, 4);

printf("Inorder traversal \n");

inorderTraversal(root);

printf("\nPreorder traversal \n");

preorderTraversal(root);

printf("\nPostorder traversal \n");

postorderTraversal(root);
}

//Inorder tree traversal using stack

vector<int> getInorderTraversal(Node* root) {
vector<int> v;
stack<Node* > s;
Node* curr = root;
while (curr != NULL || s.empty() == false) {
while (curr != NULL) {
s.push(curr);
curr = curr->left;
}
curr = s.top();
s.pop();
v.push_back(curr->data);
curr = curr->right;
}
return v;
}

//inorder tree traversal using recursion

void getInorderTraversalUtil(Node* root, vector<int> &traversal) {
if (root == NULL) {
return;
}
getInorderTraversalUtil(root->left, traversal);
traversal.push_back(root->data);
getInorderTraversalUtil(root->right, traversal);
}

vector<int> getInorderTraversal(Node* root) {

vector<int> traversal;
getInorderTraversalUtil(root, traversal);
return traversal;
}

//preorder tree traversal using recursion

void getPreorderTraversalUtil(Node* root, vector<int> &traversal) {
if (root == NULL) {
return;
}
traversal.push_back(root->data);
getPreorderTraversalUtil(root->left, traversal);
 getPreorderTraversalUtil(root->right, traversal);
}

vector<int> getPreorderTraversal(Node* root) {

vector<int> traversal;
getPreorderTraversalUtil(root, traversal);
return traversal;
}

//preorder tree traversal using recursion

void getPostorderTraversalUtil(Node* root, vector<int> &traversal) {
if (root == NULL) {
return;
}
getPostorderTraversalUtil(root->left, traversal);
getPostorderTraversalUtil(root->right, traversal);
traversal.push_back(root->data);
}
vector<int> getPostorderTraversal(Node* root) {
vector<int> traversal;
getPostorderTraversalUtil(root, traversal);
return traversal;
}

//Level order tree traversal using queue

#include <bits/stdc++.h>
using namespace std;

struct Node {
int data;
struct Node *left, *right;
};
Node* newNode(int data)
{
Node* temp = new Node;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
void LevelOrder(Node * root) {
if (root == NULL) return;
queue <Node*> q;
q.push(root);
while (q.empty() == false) {
Node * node = q.front();
cout << node -> data << " ";
q.pop();
if (node -> left != NULL)
q.push(node -> left);
if (node -> right != NULL)
q.push(node -> right);
}
}
int main() {
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
 LevelOrder(root);
return 0;
}

//Level order tree traversal using queue

void levelOrderTraversal(Node* root, vector<int> &traversal)
{
if(root == NULL) return;
queue<Node*> q;
q.push(root);
while(q.empty() == false)
{
Node* node = q.front();
traversal.push_back(node->data);
q.pop();
if(node->left != NULL)
q.push(node->left);
if(node->right != NULL)
q.push(node->right);
}
}
vector<int> getLevelOrderTraversal(Node* root) {
vector<int> traversal;
levelOrderTraversal(root, traversal);
return traversal;
}

//Level order tree traversal using queue

#include <iostream>
#include <queue>
using namespace std;

// node structure
struct Node
{
int data;
struct Node* left;
struct Node* right;
};

// Utility function to create new node to binary tree

Node* newNode(int data)
{
Node* temp = new Node;
temp-> data = data;
temp-> left = NULL;
temp-> right= NULL;
return temp;
}

// LevelOrder using single Queue

void LevelOrderQ(Node* root)
{
if(root == NULL) return;

queue< Node * > q; //create empty Queue

q.push(root); //enqueue root

 while(q.empty() == false)
{
// Print front of queue and remove it from queue
Node* node = q.front();
cout<< node->data << " ";
q.pop();

//enqueue Left child

if(node->left != NULL)
q.push(node->left);

//enqueue right child

if(node->right != NULL)
q.push(node->right);
}
}

//driver function
int main() {
Node *root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);

cout << "Level Order traversal of binary tree is \n";

LevelOrderQ(root);
return 0;
}

//Level order tree traversal using recursion

int height(Node* root){
if (root == NULL)
return 0;
else {
int lheight = height(root->left);
int rheight = height(root->right);
if (lheight > rheight) {
return (lheight + 1);
}
else {
return (rheight + 1);
}
}
}
void processCurrLevel(Node* root, vector<int> &traversal, int level){
if(root == NULL) {
return;
}
if(level == 1) {
traversal.push_back(root->data);
} else {
processCurrLevel(root->left, traversal, level-1);
processCurrLevel(root->right, traversal, level-1);
}
}
vector<int> getLevelOrderTraversal(Node* root) {
vector<int> traversal;
int h = height(root);
 int l;
for(l = 1; l <= h; l++)
processCurrLevel(root, traversal, l);
return traversal;
}

//Maximum depth of a binary tree

int getMaxDepth(Node* root) {
if(root == NULL) {
return 0;
}
int leftSubtreeDepth = getMaxDepth(root->left);
int rightSubtreeDepth = getMaxDepth(root->right);
return max(leftSubtreeDepth, rightSubtreeDepth) + 1;
}