Skip to content
Related Articles

Related Articles

Print Binary Search Tree in Min Max Fashion

View Discussion
Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 25 Oct, 2021

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:  

  1. Create an array inorder[] and store the inorder traversal of the given binary search tree.
  2. Since the inorder traversal of the binary search tree is sorted in ascending, initialise i = 0 and j = n – 1.
  3. Print inorder[i] and update i = i + 1.
  4. Print inorder[j] and update j = j – 1.
  5. 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

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!