Print nodes of a Binary Search Tree in Top Level Order and Reversed Bottom Level Order alternately

// Java program for the above approach
import java.io.*;
import java.util.*;

public class GFG {

  // Structure of a BST node
  static class node {
    int data;
    node left;
    node right;
  }

  //Structure of pair (used in PriorityQueue)
  static class pair{
    int x,y;
    pair(int xx, int yy){
      this.x=xx;
      this.y=yy;
    }
  }

  //Structure of pair (used in Stack)
  static class StackPair{
    node n;
    int x;
    StackPair(node nn, int xx){
      this.n=nn;
      this.x=xx;
    }
  }

  // Utility function to create a new BST node
  static node newnode(int d)
  {
    node temp = new node();
    temp.left = null;
    temp.right = null;
    temp.data = d;
    return temp;
  }

  //Custom Comparator for pair class to sort
  //elements in increasing order 
  static class IncreasingOrder implements Comparator<pair>{
    public int compare(pair p1, pair p2){
      if(p1.x>p2.x){
        return 1;
      }else{
        if(p1.x<p2.x){
          return -1;
        }else{
          if(p1.y>p2.y){
            return 1;
          }else{
            if(p1.y<p2.y){
              return -1;
            }else{
              return 0;
            }
          }
        }
      }
    }
  }

  // Custom Comparator for pair class to sort
  // elements in decreasing order 
  static class DecreasingOrder implements Comparator<pair>{
    public int compare(pair p1, pair p2){
      if(p1.x>p2.x){
        return -1;
      }else{
        if(p1.x<p2.x){
          return 1;
        }else{
          if(p1.y>p2.y){
            return -1;
          }else{
            if(p1.y<p2.y){
              return 1;
            }else{
              return 0;
            }
          }
        }
      }
    }
  }

  // Function to print the nodes of a
  // BST in Top Level Order and Reversed
  // Bottom Level Order alternatively
  static void printBST(node root)
  {
    // Stores the nodes in descending order
    // of the level and node values
    PriorityQueue<pair> great = new PriorityQueue<>(new DecreasingOrder());

    // Stores the nodes in ascending order
    // of the level and node values

    PriorityQueue<pair> small = new PriorityQueue<>(new IncreasingOrder());

    // Initialize a stack for
    // level order traversal
    Stack<StackPair> st = new Stack<>();

    // Push the root of BST
    // into the stack
    st.push(new StackPair(root,1));

    // Perform Level Order Traversal
    while (!st.isEmpty()) {

      // Extract and pop the node
      // from the current level
      StackPair sp = st.pop();
      node curr = sp.n;

      // Stores level of current node
      int level = sp.x;

      // Store in the priority queues
      great.add(new pair(level,curr.data));
      small.add(new pair(level,curr.data));

      // Traverse left subtree
      if (curr.left!=null)
        st.push(new StackPair(curr.left,level+1));

      // Traverse right subtree
      if (curr.right!=null)
        st.push(new StackPair(curr.right,level+1));
    }

    // Stores the levels that are printed
    HashSet<Integer> levelsprinted = new HashSet<>();

    // Print the nodes in the required manner
    while (!small.isEmpty() && !great.isEmpty()) {

      // Store the top level of traversal
      int toplevel = small.peek().x;

      // If the level is already printed
      if (levelsprinted.contains(toplevel))
        break;

      // Otherwise
      else
        levelsprinted.add(toplevel);

      // Print nodes of same level
      while (!small.isEmpty() && small.peek().x == toplevel) {
        System.out.print(small.poll().y + " ");
      }

      // Store the bottom level of traversal
      int bottomlevel = great.peek().x;

      // If the level is already printed
      if (levelsprinted.contains(bottomlevel)) {
        break;
      }
      else {
        levelsprinted.add(bottomlevel);
      }

      // Print the nodes of same level
      while (!great.isEmpty() && great.peek().x == bottomlevel) {
        System.out.print(great.poll().y + " ");
      }
    }
  }

  public static void main (String[] args) {
    /*
        Given BST

                                    25
                                  /     \
                                20      36
                               /  \      / \
                              10   22   30 40
                             /  \      /   / \
                            5   12    28  38 48
        */

    // Creating the BST
    node root = newnode(25);
    root.left = newnode(20);
    root.right = newnode(36);
    root.left.left = newnode(10);
    root.left.right = newnode(22);
    root.left.left.left = newnode(5);
    root.left.left.right = newnode(12);
    root.right.left = newnode(30);
    root.right.right = newnode(40);
    root.right.left.left = newnode(28);
    root.right.right.left = newnode(38);
    root.right.right.right = newnode(48);

    // Function Call
    printBST(root);
  }
}

// This code is contributed by shruti456rawal

import java.util.*;

// structure of tree node
class Node {
    int data;
    Node left, right;
    Node(int data)
    {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

// class to print the nodes of a
// BST in Top Level Order and Reversed
// Bottom Level Order alternatively
class Main {
    // function to find the height of binary tree
    public static int height(Node root)
    {
        if (root == null)
            return 0;
        return Math.max(height(root.left),
                        height(root.right))
            + 1;
    }

    public static void printBST(Node root)
    {
        // base case
        if (root == null)
            return;

        List<List<Integer> > ans = new ArrayList<>();
        int level = 0;

        // initializing the queue for level order traversal
        Queue<Node> q = new LinkedList<>();
        q.add(root);

        while (!q.isEmpty()) {
            int n = q.size();
            List<Integer> currLevel = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                Node front_node = q.poll();
                currLevel.add(front_node.data);
                if (front_node.left != null)
                    q.add(front_node.left);
                if (front_node.right != null)
                    q.add(front_node.right);
            }
            ans.add(currLevel);
            level++;
        }

        int it1 = 0;
        int it2 = ans.size() - 1;
        while (it1 < it2) {
            for (int i : ans.get(it1)) {
                System.out.print(i + " ");
            }
            for (int i = ans.get(it2).size() - 1; i >= 0;
                 i--) {
                System.out.print(ans.get(it2).get(i) + " ");
            }
            it1++;
            it2--;
        }
        if (it1 == it2) {
            for (int i : ans.get(it1)) {
                System.out.print(i + " ");
            }
        }
    }

    // driver code to test above function
    public static void main(String[] args)
    {
        // creating the binary tree
        Node root = new Node(25);
        root.left = new Node(20);
        root.right = new Node(36);
        root.left.left = new Node(10);
        root.left.right = new Node(22);
        root.left.left.left = new Node(5);
        root.left.left.right = new Node(12);
        root.right.left = new Node(30);
        root.right.right = new Node(40);
        root.right.left.left = new Node(28);
        root.right.right.left = new Node(38);
        root.right.right.right = new Node(48);

        printBST(root);
    }
}