You are on page 1of 10

# Level Order Traversal of Binary Tree - Techie Delight

## bool printLevel(Node* root, int level)

{
if (root == nullptr)
return false;

if (level == 1)
{
cout << root->key << " ";

return true;
}

## bool left = printLevel(root->left, level - 1);

bool right = printLevel(root->right, level - 1);

}

## // Function to print level order traversal of given binary tree

void levelOrderTraversal(Node* root)
{
if (root == nullptr)
return;

int level = 1;

## // run till printLevel() returns false

while (printLevel(root, level))
level++;
}
Spiral Order Traversal of Binary Tree - Techie Delight
bool printLevelLeftToRight(Node* root, int level)
{
if (root == nullptr)
return false;

if (level == 1)
{
cout << root->key << " ";
return true;
}

## // process left child before right child

bool left = printLevelLeftToRight(root->left, level - 1);
bool right = printLevelLeftToRight(root->right, level - 1);

}

## // Function to print all nodes of a given level from right to left

bool printLevelRightToLeft(Node* root, int level)
{
if (root == nullptr)
return false;

if (level == 1)
{
cout << root->key << " ";
return true;
}

## // process right child before left child

bool right = printLevelRightToLeft(root->right, level - 1);
bool left = printLevelRightToLeft(root->left, level - 1);

}

## // Function to print level order traversal of given binary tree

void spiralOrderTraversal(Node* root)
{
if (root == nullptr)
return;

int level = 1;

## // run till either function returns false

while (printLevelLeftToRight(root, level++) &&
printLevelRightToLeft(root, level++));
}
Find the distance between given pairs of nodes in a binary tree - Techie Delight
bool isNodePresent(Node* root, Node* node)
{
// base case
if (root == nullptr)
return false;

## // if node is found, return true

if (root == node)
return true;

## // return true if node is found in the left subtree or right subtree

return isNodePresent(root->left, node) ||
isNodePresent(root->right, node);
}

## // Helper function to find level of given node present in binary tree

int findLevel(Node *root, Node* node, int level)
{
// base case
if (root == nullptr)
return INT_MIN;
// return level if node is found
if (root == node)
return level;

## // search node in left subtree

int left = findLevel(root->left, node, level + 1);

## // if node is found in left subtree, return

if (left != INT_MIN)
return left;

## // else continue the search in right subtree

return findLevel(root->right, node, level + 1);
}

## // Function to find lowest common ancestor of given nodes x and y where

// both x and y are present in the binary tree.
Node* findLCA(Node* root, Node* x, Node* y)
{
// base case 1: if tree is empty
if (root == nullptr)
return nullptr;

## // base case 2: if either x or y is found

if (root == x || root == y)
return root;

## // recursively check if x or y exists in the left subtree

Node* left = findLCA(root->left, x, y);

## // recursively check if x or y exists in the right subtree

Node* right = findLCA(root->right, x, y);

## // if x is found in one subtree and y is found in other subtree,

// update lca to current node
if (left && right)
return root;

if (left)
return left;

## // if x and y exists in right subtree

if (right)
return right;
}

// Function to find the distance between node 'x' and node 'y' in a
// given binary tree rooted at 'root' node
int findDistance(Node *root, Node* x, Node* y)
{
// lca stores lowest common ancestor of x and y
Node *lca = nullptr;

// call LCA procedure only if both x and y are present in the tree
if (isNodePresent(root, y) && isNodePresent(root, x))
lca = findLCA(root, x, y);
else
return INT_MIN;

## // return distance of x from lca + distance of y from lca

return findLevel(lca, x, 0) + findLevel(lca, y, 0);

## // above return statement is equivalent to

// findLevel(root, x, 0) + findLevel(root, y, 0) -
// 2*findLevel(root, lca, 0);

## // we can avoid calling isNodePresent() function by using

// the return values of findLevel() function to check if
// x and y are present in the tree or not
}
Maximum width of a binary tree - GeeksforGeeks
http://www.geeksforgeeks.org/maximum-width-of-a-binary-tree/

## int getMaxWidth(struct node* root)

{
int maxWidth = 0;
int width;
int h = height(root);
int i;

## /* Get width of each level and compare

the width with maximum width so far */
for(i=1; i<=h; i++)
{
width = getWidth(root, i);
if(width > maxWidth)
maxWidth = width;
}

return maxWidth;
}

## /* Get width of a given level */

int getWidth(struct node* root, int level)
{

if(root == NULL)
return 0;

if(level == 1)
return 1;

## else if (level > 1)

return getWidth(root->left, level-1) +
getWidth(root->right, level-1);
}

## // A function that fills count array with count of nodes at every

// level of given binary tree
void getMaxWidthRecur(struct node *root, int count[], int level);

## /* Function to get the maximum width of a binary tree*/

int getMaxWidth(struct node* root)
{
int width;
int h = height(root);

## // Create an array that will store count of nodes at each level

int *count = (int *)calloc(sizeof(int), h);

int level = 0;

## // Fill the count array using preorder traversal

getMaxWidthRecur(root, count, level);

## // Return the maximum value from count array

return getMax(count, h);
}

## // A function that fills count array with count of nodes at every

// level of given binary tree
void getMaxWidthRecur(struct node *root, int count[], int level)
{
if(root)
{
count[level]++;
getMaxWidthRecur(root->left, count, level+1);
getMaxWidthRecur(root->right, count, level+1);
}
}

## Find depth of the deepest odd level leaf node - GeeksforGeeks

http://www.geeksforgeeks.org/find-depth-of-the-deepest-odd-level-node/
int depthOfOddLeafUtil(Node *root,int level)
{
// Base Case
if (root == NULL)
return 0;

// If this node is a leaf and its level is odd, return its level
if (root->left==NULL && root->right==NULL && level&1)
return level;

// If not leaf, return the maximum value from left and right subtrees
return max(depthOfOddLeafUtil(root->left, level+1),
depthOfOddLeafUtil(root->right, level+1));
}

/* Main function which calculates the depth of deepest odd level leaf.
This function mainly uses depthOfOddLeafUtil() */
int depthOfOddLeaf(struct Node *root)
{
int level = 1, depth = 0;
return depthOfOddLeafUtil(root, level);
}

## Check if all leaves are at same level - GeeksforGeeks

http://www.geeksforgeeks.org/check-leaves-level/

## bool checkUtil(struct Node *root, int level, int *leafLevel)

{
// Base case
if (root == NULL) return true;

## // If a leaf node is encountered

if (root->left == NULL && root->right == NULL)
{
// When a leaf node is found first time
if (*leafLevel == 0)
{
*leafLevel = level; // Set first found leaf's level
return true;
}

## // If this is not first leaf node, compare its level with

// first leaf's level
return (level == *leafLevel);
}
// If this node is not leaf, recursively check left and right subtrees
return checkUtil(root->left, level+1, leafLevel) &&
checkUtil(root->right, level+1, leafLevel);
}

## /* The main function to check if all leafs are at same level.

It mainly uses checkUtil() */
bool check(struct Node *root)
{
int level = 0, leafLevel = 0;
return checkUtil(root, level, &leafLevel);
}

## Print Left View of a Binary Tree - GeeksforGeeks

http://www.geeksforgeeks.org/print-left-view-binary-tree/

## void leftViewUtil(struct node *root, int level, int *max_level)

{
// Base Case
if (root==NULL) return;

## // If this is the first node of its level

if (*max_level < level)
{
printf("%d\t", root->data);
*max_level = level;
}

## // Recur for left and right subtrees

leftViewUtil(root->left, level+1, max_level);
leftViewUtil(root->right, level+1, max_level);
}

## // A wrapper over leftViewUtil()

void leftView(struct node *root)
{
int max_level = 0;
leftViewUtil(root, 1, &max_level);
}

## Deepest left leaf node in a binary tree - GeeksforGeeks

http://www.geeksforgeeks.org/deepest-left-leaf-node-in-a-binary-tree/

## void deepestLeftLeafUtil(Node *root, int lvl, int *maxlvl,

bool isLeft, Node **resPtr)
{
// Base case
if (root == NULL)
return;

// Update result if this node is left leaf and its level is more
// than the maxl level of the current result
if (isLeft && !root->left && !root->right && lvl > *maxlvl)
{
*resPtr = root;
*maxlvl = lvl;
return;
}

## // Recur for left and right subtrees

deepestLeftLeafUtil(root->left, lvl+1, maxlvl, true, resPtr);
deepestLeftLeafUtil(root->right, lvl+1, maxlvl, false, resPtr);
}

## // A wrapper over deepestLeftLeafUtil().

Node* deepestLeftLeaf(Node *root)
{
int maxlevel = 0;
Node *result = NULL;
deepestLeftLeafUtil(root, 0, &maxlevel, false, &result);
return result;
}

## Check if two nodes are cousins in a Binary Tree - GeeksforGeeks

http://www.geeksforgeeks.org/check-two-nodes-cousins-binary-tree/

int isSibling(struct Node *root, struct Node *a, struct Node *b)
{
// Base case
if (root==NULL) return 0;

## return ((root->left==a && root->right==b)||

(root->left==b && root->right==a)||
isSibling(root->left, a, b)||
isSibling(root->right, a, b));
}

## // Recursive function to find level of Node 'ptr' in a binary tree

int level(struct Node *root, struct Node *ptr, int lev)
{
// base cases
if (root == NULL) return 0;
if (root == ptr) return lev;

## // Return level if Node is present in left subtree

int l = level(root->left, ptr, lev+1);
if (l != 0) return l;

## // Else search in right subtree

return level(root->right, ptr, lev+1);
}

## // Returns 1 if a and b are cousins, otherwise 0

int isCousin(struct Node *root, struct Node *a, struct Node *b)
{
//1. The two Nodes should be on the same level in the binary tree.
//2. The two Nodes should not be siblings (means that they should
// not have the same parent Node).
if ((level(root,a,1) == level(root,b,1)) && !(isSibling(root,a,b)))
return 1;
else return 0;
}

## Swap Nodes in Binary tree of every k'th level - GeeksforGeeks

http://www.geeksforgeeks.org/swap-nodes-binary-tree-every-kth-level/

## // A utility function swap left- node & right node of tree

// of every k'th level
void swapEveryKLevelUtil( Node *root, int level, int k)
{
// base case
if (root== NULL ||
(root->left==NULL && root->right==NULL) )
return ;

## //if current level + 1 is present in swap vector

//then we swap left & right node
if ( (level + 1) % k == 0)
Swap(&root->left, &root->right);

## // Recur for left and right subtrees

swapEveryKLevelUtil(root->left, level+1, k);
swapEveryKLevelUtil(root->right, level+1, k);
}

## // This function mainly calls recursive function

// swapEveryKLevelUtil()
void swapEveryKLevel(Node *root, int k)
{
// call swapEveryKLevelUtil function with
// initial level as 1.
swapEveryKLevelUtil(root, 1, k);
}