# Middle To Up-Down Order traversal of a Binary Tree

• Last Updated : 15 Jun, 2021

Given a binary tree, the task is to traverse this binary tree from the middle to the up-down order.
In Middle to up-down order traversal, the following steps are performed:

1. First, print the middle level of the tree.
2. Then, print the elements at one level above the middle level of the tree.
3. Then, print the elements at one level below the middle level of the tree.
4. Then, print the elements at two levels above the middle level of the tree.
5. Then, print the elements at two levels below the middle level of the tree and so on.

Note: In this problem, the middle level is considered at ((H / 2) + 1)th level where H is the height of the tree and the level of the root is considered as 1.

Examples:

```Input:
10
/     \
12     13
/       \
14        15
/ \       / \
21 22     23 24
Output:
14, 15,
12, 13,
21, 22, 23, 24,
10,
Explanation:
There are 4 levels in the tree.
Therefore, Middle level = ((4 / 2) + 1) = 3
Now, the tree is traversed in the following way:
Middle level: 14, 15
One level above the middle level: 12, 13
One level below the middle level: 21, 22, 23, 24
Two levels above the middle level: 10

Input:
5
/   \
2      13
/   \      \
4    25       6
/      / \
11       3 21
\
9
Output:
4, 25, 6
2, 13
11, 3, 21
5
9
Explanation:
There are 5 levels in the tree.
Therefore, Middle level = ((5 / 2) + 1) = 3.
Now, the tree is traversed in the following way:
Middle level: 4, 25, 6
One level above the middle level: 2, 13
One level below the middle level: 11, 3, 21
Two levels above the middle level: 5
Two levels below the middle level: 9```

Approach: The idea is to store the tree in a matrix. In order to do that,

• The height and width of the tree are computed.
• After computing the height and maximum width, a 2d matrix is created and a breadth-first search is performed on the tree to store the tree in the matrix.
For example:

• Then, simply iterate over the matrix and print the values from the matrix as per the given condition.

Below is the implementation of the above approach:

## C++

 `// C++ program to traverse the tree``// from the middle to up and down` `#include ``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 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``void` `findWidth(``struct` `Node* node, ``int``& maxValue,``               ``int``& minValue, ``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, 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;` `    ``// Iterating over the queue to perform``    ``// breadth-first search traversal``    ``while` `(!qu.empty()) {` `        ``i++;` `        ``int` `qsize = qu.size();` `        ``while` `(qsize--) {``            ``j++;` `            ``poped_node = qu.front();` `            ``// Store the data of the node into``            ``// the matrix``            ``mtrx[i][j] = poped_node->key;``            ``qu.pop();` `            ``// Performing BFS for the remaining``            ``// nodes in the queue``            ``if` `(poped_node->left != NULL) {``                ``qu.push(poped_node->left);``            ``}` `            ``if` `(poped_node->right != NULL) {``                ``qu.push(poped_node->right);``            ``}``        ``}` `        ``j = -1;``    ``}``}` `// Function for Middle to Up Down``// Traversal of Binary Tree``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] != INT_MAX) {``            ``cout << mtrx[up][j] << ``", "``;``        ``}``    ``}``    ``cout << endl;``    ``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] != INT_MAX) {``                ``cout << mtrx[k][j] << ``", "``;``            ``}``        ``}``        ``cout << endl;``    ``}``}` `// A utility function for middle to``// up down traversal``void` `printPattern(``struct` `Node* node)``{``    ``// max, min has been taken for``    ``// calculating the 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);` `    ``// Double pointer to create 2D array``    ``int``** mtrx = ``new` `int``*[height];` `    ``// Initialize the width for``    ``// each row of the 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 ``    ``*/` `    ``// 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);` `    ``return` `0;``}`

## Java

 `// Java program to traverse the tree``// from the middle to up and down``import` `java.util.*;` `class` `GFG{` `// A Tree node``static` `class` `Node {``    ``int` `key;``    ``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` `LinkedList();` `    ``qu.add(node);` `    ``int` `i = -``1``, j = -``1``;` `    ``Node poped_node = ``null``;` `    ``// Iterating over the queue to perform``    ``// breadth-first search traversal``    ``while` `(!qu.isEmpty()) {` `        ``i++;` `        ``int` `qsize = qu.size();` `        ``while` `(qsize-- > ``0``) {``            ``j++;` `            ``poped_node = qu.peek();` `            ``// Store the data of the node into``            ``// the matrix``            ``mtrx[i][j] = poped_node.key;``            ``qu.remove();` `            ``// Performing BFS for the remaining``            ``// nodes in the queue``            ``if` `(poped_node.left != ``null``) {``                ``qu.add(poped_node.left);``            ``}` `            ``if` `(poped_node.right != ``null``) {``                ``qu.add(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``;` `    ``boolean` `flag = ``true``;``    ``int` `k = ``0``;` `    ``// Print the middle row``    ``for` `(``int` `j = ``0``; j < width; j++) {``        ``if` `(mtrx[up][j] != Integer.MAX_VALUE) {``            ``System.out.print(mtrx[up][j]+ ``", "``);``        ``}``    ``}``    ``System.out.println();``    ``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] != Integer.MAX_VALUE) {``                ``System.out.print(mtrx[k][j]+ ``", "``);``            ``}``        ``}``        ``System.out.println();``    ``}``}` `// 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 = Integer.MIN_VALUE;``    ``minValue = Integer.MAX_VALUE;``    ``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] = Integer.MAX_VALUE;``        ``}``    ``}` `    ``// 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 Rajput-Ji`

## Python3

 `# Python3 program for the``# above approach``from` `collections ``import` `deque` `# A Tree node``class` `Node:``  ` `    ``def` `__init__(``self``, x):``      ` `        ``self``.key ``=` `x``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `minValue, maxValue ``=` `0``, ``0` `# Function to calculate the``# height of the tree``def` `findHeight(node):``  ` `    ``# Base condition``    ``if` `(node ``=``=` `None``):``        ``return` `0``    ``leftHeight ``=` `findHeight(node.left)``    ``rightHeight ``=` `findHeight(node.right)` `    ``# Return the maximum of the height``    ``# of the left and right subtree``    ``if` `leftHeight > rightHeight:``        ``return` `leftHeight ``+` `1` `    ``return` `rightHeight ``+` `1` `# Function to find the width``# of the tree``def` `findWidth(node, hd):``   ` `    ``global` `minValue, maxValue``    ` `    ``# Base cases``    ``if` `(node ``=``=` `None``):``        ``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``def` `BFS(mtrx, node):``  ` `    ``# Create queue for storing``    ``# the addresses of nodes``    ``qu ``=` `deque()` `    ``qu.append(node)``    ``i ``=` `-``1``    ``j ``=` `-``1``    ``poped_node ``=` `None` `    ``# Iterating over the queue``    ``# to perform breadth-first``    ``# search traversal``    ``while` `(``len``(qu) > ``0``):``        ``i ``+``=` `1``        ``qsize ``=` `len``(qu)``        ``while` `(qsize):``            ``j ``+``=` `1``            ``poped_node ``=` `qu.popleft()` `            ``# Store the data of the``            ``# node into the matrix``            ``mtrx[i][j] ``=` `poped_node.key``            ``#qu.pop()` `            ``# Performing BFS for``            ``# the remaining nodes``            ``# in the queue``            ``if` `(poped_node.left !``=` `None``):``                ``qu.append(poped_node.left)` `            ``if` `(poped_node.right !``=` `None``):``                ``qu.append(poped_node.right)``            ``qsize ``-``=` `1` `        ``j ``=` `-``1` `#Function for Middle to Up Down``#Traversal of Binary Tree``def` `traverse_matrix(mtrx,``                    ``height,width):``  ` `    ``# Variables to handle rows``    ``# and columns of the matrix``    ``up ``=` `(height ``/``/` `2``)``    ``down ``=` `up ``+` `1` `    ``flag ``=` `True``    ``k ``=` `0` `    ``# Print middle row``    ``for` `j ``in` `range``(width):``        ``if` `(mtrx[up][j] !``=` `10` `*``*` `9``):``            ``print``(mtrx[up][j], end ``=` `", "``)``    ``print``()``    ``up ``-``=` `1` `    ``# Loop to print the remaining rows``    ``for` `i ``in` `range``(height ``-` `1``):` `        ``# Condition to manage up and``        ``# down indices in the matrix``        ``if` `(flag):``            ``k ``=` `up``            ``up ``-``=` `1``            ``flag ``=` `not` `flag``        ``else``:``            ``k ``=` `down``            ``down ``+``=` `1``            ``flag ``=` `not` `flag` `        ``# Loop to print the value``        ``# of matrix cells in``        ``# particular row``        ``for` `j ``in` `range``(width):``            ``if` `(mtrx[k][j] !``=` `10` `*``*` `9``):``                ``print``(mtrx[k][j], end ``=` `", "``)``        ``print``()` `# A utility function for middle to``# up down traversal``def` `printPattern(node):``  ` `    ``global` `maxValue, minValue``    ` `    ``# max, min has been taken for``    ``# calculating the width of tree``    ``maxValue ``=` `-``10` `*``*` `9``    ``minValue ``=` `10` `*``*` `9``    ``hd ``=` `0` `    ``# Calculate the width``    ``# of a tree``    ``findWidth(node, hd)``    ``width ``=` `maxValue ``+` `abs``(minValue)` `    ``# Calculate the height of the tree``    ``height ``=` `findHeight(node)``    ` `    ``# print(height,width)` `    ``#Double pointer to create 2D array``    ``mtrx ``=` `[[``10` `*``*` `9` `for` `i ``in` `range``(width ``+` `1``)]``                     ``for` `i ``in` `range``(height ``+` `1``)]` `    ``# Store the BFS traversal of the tree``    ``# into the 2-D matrix``    ``BFS(mtrx, node)` `    ``# Print circular clockwise spiral``    ``# traversal of the tree``    ``traverse_matrix(mtrx, height, width)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# /*``    ``#               10``    ``#            /     \``    ``#           12     13``    ``#           /       \``    ``#          14        15``    ``#          / \       / \``    ``#         21 22     23 24``    ``# */` `    ``# Creating the above tree``    ``root ``=` `Node(``10``)``    ``root.left ``=` `Node(``12``)``    ``root.right ``=` `Node(``13``)` `    ``root.right.left ``=` `Node(``14``)``    ``root.right.right ``=` `Node(``15``)` `    ``root.right.left.left ``=` `Node(``21``)``    ``root.right.left.right ``=` `Node(``22``)``    ``root.right.right.left ``=` `Node(``23``)``    ``root.right.right.right ``=` `Node(``24``)` `    ``printPattern(root)` `# This code is contributed by Mohit Kumar 29`

## C#

 `// 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`

## Javascript

 ``

Output:

```14, 15,
12, 13,
21, 22, 23, 24,
10,```

My Personal Notes arrow_drop_up