Print Binary Search Tree in Min Max Fashion
Given a Binary Search Tree (BST), the task is to print the BST in min-max fashion.
What is min-max fashion?
A min-max fashion means you have to print the maximum node first then the minimum then the second maximum then the second minimum and so on.
Examples:
Input: 100 / \ 20 500 / \ 10 30 \ 40 Output: 10 500 20 100 30 40 Input: 40 / \ 20 50 / \ \ 10 35 60 / / 25 55 Output: 10 60 20 55 25 50 35 40
Approach:
- Create an array inorder[] and store the inorder traversal of the given binary search tree.
- Since the inorder traversal of the binary search tree is sorted in ascending, initialise i = 0 and j = n – 1.
- Print inorder[i] and update i = i + 1.
- Print inorder[j] and update j = j – 1.
- Repeat steps 3 and 4 until all the elements have been printed.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach #include <iostream> using namespace std; // Structure of each node of BST struct node { int key; struct node *left, *right; }; // A utility function to create a new BST node node* newNode( int item) { node* temp = new node(); temp->key = item; temp->left = temp->right = NULL; return temp; } /* A utility function to insert a new node with given key in BST */ struct node* insert( struct node* node, int key) { /* If the tree is empty, return a new node */ if (node == NULL) return newNode(key); /* Otherwise, recur down the tree */ if (key < node->key) node->left = insert(node->left, key); else if (key > node->key) node->right = insert(node->right, key); /* return the (unchanged) node pointer */ return node; } // Function to return the size of the tree int sizeOfTree(node* root) { if (root == NULL) { return 0; } // Calculate left size recursively int left = sizeOfTree(root->left); // Calculate right size recursively int right = sizeOfTree(root->right); // Return total size recursively return (left + right + 1); } // Utility function to print the // Min max order of BST void printMinMaxOrderUtil(node* root, int inOrder[], int & index) { // Base condition if (root == NULL) { return ; } // Left recursive call printMinMaxOrderUtil(root->left, inOrder, index); // Store elements in inorder array inOrder[index++] = root->key; // Right recursive call printMinMaxOrderUtil(root->right, inOrder, index); } // Function to print the // Min max order of BST void printMinMaxOrder(node* root) { // Store the size of BST int numNode = sizeOfTree(root); // Take auxiliary array for storing // The inorder traversal of BST int inOrder[numNode + 1]; int index = 0; // Function call for printing // element in min max order printMinMaxOrderUtil(root, inOrder, index); int i = 0; index--; // While loop for printing elements // In front last order while (i < index) { cout << inOrder[i++] << " " << inOrder[index--] << " " ; } if (i == index) { cout << inOrder[i] << endl; } } // Driver code int main() { struct node* root = NULL; root = insert(root, 50); insert(root, 30); insert(root, 20); insert(root, 40); insert(root, 70); insert(root, 60); insert(root, 80); printMinMaxOrder(root); return 0; } |
Java
// Java implementation of the approach class GFG { // Structure of each node of BST static class node { int key; node left, right; }; static int index; // A utility function to create a new BST node static node newNode( int item) { node temp = new node(); temp.key = item; temp.left = temp.right = null ; return temp; } /* A utility function to insert a new node with given key in BST */ static node insert(node node, int key) { /* If the tree is empty, return a new node */ if (node == null ) return newNode(key); /* Otherwise, recur down the tree */ if (key < node.key) node.left = insert(node.left, key); else if (key > node.key) node.right = insert(node.right, key); /* return the (unchanged) node pointer */ return node; } // Function to return the size of the tree static int sizeOfTree(node root) { if (root == null ) { return 0 ; } // Calculate left size recursively int left = sizeOfTree(root.left); // Calculate right size recursively int right = sizeOfTree(root.right); // Return total size recursively return (left + right + 1 ); } // Utility function to print the // Min max order of BST static void printMinMaxOrderUtil(node root, int inOrder[]) { // Base condition if (root == null ) { return ; } // Left recursive call printMinMaxOrderUtil(root.left, inOrder); // Store elements in inorder array inOrder[index++] = root.key; // Right recursive call printMinMaxOrderUtil(root.right, inOrder); } // Function to print the // Min max order of BST static void printMinMaxOrder(node root) { // Store the size of BST int numNode = sizeOfTree(root); // Take auxiliary array for storing // The inorder traversal of BST int []inOrder = new int [numNode + 1 ]; // Function call for printing // element in min max order printMinMaxOrderUtil(root, inOrder); int i = 0 ; index--; // While loop for printing elements // In front last order while (i < index) { System.out.print(inOrder[i++] + " " + inOrder[index--] + " " ); } if (i == index) { System.out.println(inOrder[i]); } } // Driver code public static void main(String[] args) { node root = null ; root = insert(root, 50 ); insert(root, 30 ); insert(root, 20 ); insert(root, 40 ); insert(root, 70 ); insert(root, 60 ); insert(root, 80 ); printMinMaxOrder(root); } } // This code is contributed by 29AjayKumar |
Python3
# Python3 implementation of the approach # Structure of each node of BST class Node: def __init__( self ,key): self .left = None self .right = None self .val = key def insert(root,node): if root is None : root = Node(node) else : if root.val < node: if root.right is None : root.right = Node(node) else : insert(root.right, node) else : if root.left is None : root.left = Node(node) else : insert(root.left, node) # Function to return the size of the tree def sizeOfTree(root): if root = = None : return 0 # Calculate left size recursively left = sizeOfTree(root.left) # Calculate right size recursively right = sizeOfTree(root.right); # Return total size recursively return (left + right + 1 ) # Utility function to print the # Min max order of BST def printMinMaxOrderUtil(root, inOrder, index): # Base condition if root = = None : return # Left recursive call printMinMaxOrderUtil(root.left, inOrder, index) # Store elements in inorder array inOrder[index[ 0 ]] = root.val index[ 0 ] + = 1 # Right recursive call printMinMaxOrderUtil(root.right, inOrder, index) # Function to print the # Min max order of BST def printMinMaxOrder(root): # Store the size of BST numNode = sizeOfTree(root); # Take auxiliary array for storing # The inorder traversal of BST inOrder = [ 0 ] * (numNode + 1 ) index = 0 # Function call for printing # element in min max order ref = [index] printMinMaxOrderUtil(root, inOrder, ref) index = ref[ 0 ] i = 0 ; index - = 1 # While loop for printing elements # In front last order while (i < index): print (inOrder[i], inOrder[index], end = ' ' ) i + = 1 index - = 1 if i = = index: print (inOrder[i]) # Driver Code root = Node( 50 ) insert(root, 30 ) insert(root, 20 ) insert(root, 40 ) insert(root, 70 ) insert(root, 60 ) insert(root, 80 ) printMinMaxOrder(root) # This code is contributed by Sadik Ali |
C#
// C# implementation of the approach using System; class GFG { // Structure of each node of BST class node { public int key; public node left, right; }; static int index; // A utility function to create a new BST node static node newNode( int item) { node temp = new node(); temp.key = item; temp.left = temp.right = null ; return temp; } /* A utility function to insert a new node with given key in BST */ static node insert(node node, int key) { /* If the tree is empty, return a new node */ if (node == null ) return newNode(key); /* Otherwise, recur down the tree */ if (key < node.key) node.left = insert(node.left, key); else if (key > node.key) node.right = insert(node.right, key); /* return the (unchanged) node pointer */ return node; } // Function to return the size of the tree static int sizeOfTree(node root) { if (root == null ) { return 0; } // Calculate left size recursively int left = sizeOfTree(root.left); // Calculate right size recursively int right = sizeOfTree(root.right); // Return total size recursively return (left + right + 1); } // Utility function to print the // Min max order of BST static void printMinMaxOrderUtil(node root, int []inOrder) { // Base condition if (root == null ) { return ; } // Left recursive call printMinMaxOrderUtil(root.left, inOrder); // Store elements in inorder array inOrder[index++] = root.key; // Right recursive call printMinMaxOrderUtil(root.right, inOrder); } // Function to print the // Min max order of BST static void printMinMaxOrder(node root) { // Store the size of BST int numNode = sizeOfTree(root); // Take auxiliary array for storing // The inorder traversal of BST int []inOrder = new int [numNode + 1]; // Function call for printing // element in min max order printMinMaxOrderUtil(root, inOrder); int i = 0; index--; // While loop for printing elements // In front last order while (i < index) { Console.Write(inOrder[i++] + " " + inOrder[index--] + " " ); } if (i == index) { Console.WriteLine(inOrder[i]); } } // Driver code public static void Main(String[] args) { node root = null ; root = insert(root, 50); insert(root, 30); insert(root, 20); insert(root, 40); insert(root, 70); insert(root, 60); insert(root, 80); printMinMaxOrder(root); } } // This code is contributed by PrinciRaj1992 |
Javascript
<script> // Javascript implementation of the approach // Structure of each node of BST class node { constructor() { this .key = 0; this .left = null ; this .right = null ; } }; var index = 0; // A utility function to create a new BST node function newNode(item) { var temp = new node(); temp.key = item; temp.left = temp.right = null ; return temp; } // A utility function to insert a new // node with given key in BST function insert(node, key) { /* If the tree is empty, return a new node */ if (node == null ) return newNode(key); /* Otherwise, recur down the tree */ if (key < node.key) node.left = insert(node.left, key); else if (key > node.key) node.right = insert(node.right, key); /* return the (unchanged) node pointer */ return node; } // Function to return the size of the tree function sizeOfTree(root) { if (root == null ) { return 0; } // Calculate left size recursively var left = sizeOfTree(root.left); // Calculate right size recursively var right = sizeOfTree(root.right); // Return total size recursively return (left + right + 1); } // Utility function to print the // Min max order of BST function printMinMaxOrderUtil(root, inOrder) { // Base condition if (root == null ) { return ; } // Left recursive call printMinMaxOrderUtil(root.left, inOrder); // Store elements in inorder array inOrder[index++] = root.key; // Right recursive call printMinMaxOrderUtil(root.right, inOrder); } // Function to print the // Min max order of BST function printMinMaxOrder(root) { // Store the size of BST var numNode = sizeOfTree(root); // Take auxiliary array for storing // The inorder traversal of BST var inOrder = Array(numNode+1); // Function call for printing // element in min max order printMinMaxOrderUtil(root, inOrder); var i = 0; index--; // While loop for printing elements // In front last order while (i < index) { document.write(inOrder[i++] + " " + inOrder[index--] + " " ); } if (i == index) { document.write(inOrder[i]); } } // Driver code var root = null ; root = insert(root, 50); insert(root, 30); insert(root, 20); insert(root, 40); insert(root, 70); insert(root, 60); insert(root, 80); printMinMaxOrder(root); // This code is contributed by noob2000 </script> |
Output:
20 80 30 70 40 60 50