Clockwise Spiral Traversal of Binary Tree

// C++ program for Clockwise Spiral Traversal 
// of Binary Tree 

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

// A Tree node 
struct Node { 
    int key; 
    struct Node *left, *right; 
}; 

// Utility function to create a new node 
Node* newNode(int key) 
{ 
    Node* temp = new Node; 
    temp->key = key; 
    temp->left = temp->right = NULL; 
    return (temp); 
} 
//function to calculate the height of the tree
int findHeight(struct Node* node)
{
    //Base condition
    if(node == NULL) return 0;
    int leftHeight = findHeight(node->left);
    int rightHeight = findHeight(node->right);
    //return maximum of left or right subtree height addition with one
    return 1+(leftHeight > rightHeight ? leftHeight : rightHeight );
}
// Function to find the width of tree 
void findWidth(struct Node* node, int& maxValue, 
            int& minValue, int hd) 
{ 
    if (node == NULL) 
        return; 

    if (hd > maxValue) { 
        maxValue = hd; 
    } 

    if (hd < minValue) { 
        minValue = hd; 
    } 

    findWidth(node->left, maxValue, minValue, hd - 1); 
    findWidth(node->right, maxValue, minValue, hd + 1); 
} 

// Function to traverse the tree and 
// store level order traversal in a matrix 
void BFS(int** mtrx, struct Node* node) 
{ 
    // Create queue for storing 
    // the addresses of nodes 
    queue<struct Node*> qu; 

    qu.push(node); 

    int i = -1, j = -1; 

    struct Node* poped_node = NULL; 

    while (!qu.empty()) { 

        i++; 

        int qsize = qu.size(); 

        while (qsize--) { 
            j++; 

            poped_node = qu.front(); 

            // Store data of node into the matrix 
            mtrx[i][j] = poped_node->key; 
            qu.pop(); 

            if (poped_node->left != NULL) { 
                qu.push(poped_node->left); 
            } 

            if (poped_node->right != NULL) { 
                qu.push(poped_node->right); 
            } 
        } 

        j = -1; 
    } 
} 

// Function for Clockwise Spiral Traversal 
// of Binary Tree 
void traverse_matrix(int** mtrx, int height, int width) 
{ 
    int j = 0, k1 = 0, k2 = 0, k3 = height - 1; 
    int k4 = width - 1; 

    for (int round = 0; round < height / 2; round++) { 
        for (j = k2; j < width; j++) { 

            // only print those values which 
            // are not MAX_INTEGER 
            if (mtrx[k1][j] != INT_MAX) { 
                cout << mtrx[k1][j] << ", "; 
            } 
        } 

        k2 = 0; 
        k1++; 

        for (j = k4; j >= 0; j--) { 

            // only print those values which are 
            // not MAX_INTEGER 
            if (mtrx[k3][j] != INT_MAX) { 
                cout << mtrx[k3][j] << ", "; 
            } 
        } 

        k4 = width - 1; 
        k3--; 
    } 

    // condition (one row may be left traversing) 
    // if number of rows in matrix are odd 
    if (height % 2 != 0) { 
        for (j = k2; j < width; j++) { 

            // only print those values which are 
            // not MAX_INTEGER 
            if (mtrx[k1][j] != INT_MAX) { 
                cout << mtrx[k1][j] << ", "; 
            } 
        } 
    } 
} 

// A utility function to print clockwise 
// spiral traversal of tree 
void printPattern(struct Node* node) 
{ 
    // max, min has taken for 
    // calculating width of tree 
    int max_value = INT_MIN; 
    int min_value = INT_MAX; 
    int hd = 0; 

    // calculate the width of a tree 
    findWidth(node, max_value, min_value, hd); 
    int width = max_value + abs(min_value); 
   
    //calculate the height of the tree
    int height = findHeight(node); 
   
    // use double pointer to create 2D array 
    int** mtrx = new int*[height]; 

    // initialize width for each row of matrix 
    for (int i = 0; i < height; i++) { 
        mtrx[i] = new int[width]; 
    } 

    // initialize complete matrix with 
    // MAX INTEGER(purpose garbage) 
    for (int i = 0; i < height; i++) { 
        for (int j = 0; j < width; j++) { 
            mtrx[i][j] = INT_MAX; 
        } 
    } 

    // Store the BFS traversal of the tree 
    // into the 2-D matrix 
    BFS(mtrx, node); 

    // Print the circular clockwise spiral 
    // traversal of the tree 
    traverse_matrix(mtrx, height, width); 

    // release extra memory 
    // allocated for matrix 
    free(mtrx); 
} 

// Driver Code 
int main() 
{ 
    /*     10 
        /     \ 
    12     13 
        /     \ 
        14     15 
        / \     / \ 
        21 22 23 24 
        
    Let us create Binary Tree as shown 
    in above example */

    Node* root = newNode(10); 
    root->left = newNode(12); 
    root->right = newNode(13); 
  
    root->right->left = newNode(14); 
    root->right->right = newNode(15); 
  
    root->right->left->left = newNode(21); 
    root->right->left->right = newNode(22); 
    root->right->right->left = newNode(23); 
    root->right->right->right = newNode(24); 

    cout << "Circular Clockwise Spiral Traversal : \n"; 

    printPattern(root); 

    return 0; 
} 
// This code is contributed by MOHAMMAD MUDASSIR