Middle To Up-Down Order traversal of a Binary Tree

// C# program to traverse the tree 
// from the middle to up and down 
using System;
using System.Collections;
using System.Collections.Generic;

class GFG
{ 
 
// A Tree node 
class Node 
{ 
    public int key; 
    public Node left, right; 
}; 

static int maxValue, minValue;
 
// Utility function to create 
// a new node 
static 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 
static int findHeight(Node node) 
{ 
    // Base condition 
    if (node == null) 
        return 0; 
    int leftHeight = findHeight(node.left); 
    int rightHeight = findHeight(node.right); 
 
    // Return the maximum of the height 
    // of the left and right subtree 
    return 1 + (leftHeight > rightHeight 
                    ? leftHeight 
                    : rightHeight); 
} 
 
// Function to find the width of the tree 
static void findWidth(Node node, int hd) 
{ 
    // Base cases 
    if (node == null) 
        return; 
 
    if (hd > maxValue) { 
        maxValue = hd; 
    } 
 
    if (hd < minValue) { 
        minValue = hd; 
    } 
 
    // Recursively call the function twice to find 
    // the maximum width 
    findWidth(node.left, hd - 1); 
    findWidth(node.right, hd + 1); 
} 
 
// Function to traverse the tree and 
// store level order traversal in a matrix 
static void BFS(int [,]mtrx, Node node) 
{ 
    // Create queue for storing 
    // the addresses of nodes 
    Queue qu = new Queue();  
    qu.Enqueue(node); 
    int i = -1, j = -1; 
    Node poped_node = null; 
 
    // Iterating over the queue to perform 
    // breadth-first search traversal 
    while (qu.Count != 0)
    { 
        i++; 
        int qsize = qu.Count; 
        while (qsize-- > 0) { 
            j++; 
 
            poped_node = (Node)qu.Peek(); 
 
            // Store the data of the node into 
            // the matrix 
            mtrx[i,j] = poped_node.key; 
            qu.Dequeue(); 
 
            // Performing BFS for the remaining 
            // nodes in the queue 
            if (poped_node.left != null) { 
                qu.Enqueue(poped_node.left); 
            } 
 
            if (poped_node.right != null) { 
                qu.Enqueue(poped_node.right); 
            } 
        } 
 
        j = -1; 
    } 
} 
 
// Function for Middle to Up Down 
// Traversal of Binary Tree 
static void traverse_matrix(int [,]mtrx, int height, 
                    int width) 
{ 
    // Variables to handle rows and columns 
    // of the matrix 
    int up = (height / 2); 
    int down = up + 1; 
 
    bool flag = true; 
    int k = 0; 
 
    // Print the middle row 
    for (int j = 0; j < width; j++) { 
        if (mtrx[up, j] != 100000000) { 
            Console.Write(mtrx[up,j]+ ", "); 
        } 
    } 
    Console.WriteLine(); 
    up--; 
 
    // Loop to print the remaining rows 
    for (int i = 0; i < (height - 1); i++)
    { 
 
        // Condition to manage up and 
        // down indices in the matrix 
        if (flag) { 
            k = up; 
            up--; 
            flag = !flag; 
        } 
 
        else { 
            k = down; 
            down++; 
            flag = !flag; 
        } 
 
        // Loop to print the value 
        // of matrix cells in particular row 
        for (int j = 0; j < width; j++)
        { 
 
            if (mtrx[k, j] != 100000000) { 
                Console.Write(mtrx[k,j]+ ", "); 
            } 
        } 
        Console.WriteLine(); 
    } 
} 
 
// A utility function for middle to 
// up down traversal 
static void printPattern(Node node) 
{ 
    // max, min has been taken for 
    // calculating the width of tree 
    maxValue = -100000000; 
    minValue = 100000000; 
    int hd = 0; 
 
    // Calculate the width of a tree 
    findWidth(node, hd); 
    int width = maxValue + Math.Abs(minValue);
 
    // Calculate the height of the tree 
    int height = findHeight(node); 
     
    // Double pointer to create 2D array 
    int [,]mtrx = new int[width,height]; 
 
    // 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] = 100000000; 
        } 
    } 
 
    // 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 
    mtrx = null; 
} 
 
// Driver Code 
public static void Main(string[] args) 
{ 
    /* 
                10 
            / \ 
            12 13 
            / \ 
            14 15 
            / \ / \ 
            21 22 23 24 
    */
 
    // Creating the above tree 
    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); 
 
    printPattern(root); 
} 
} 

// This code is contributed by rutvik_56