Print all the levels with odd and even number of nodes in it | Set-2

// Java program to print all levels
// with odd and even number of nodes
import java.util.*;
public class Main
{
    // Function for BFS in a tree
    static void bfs(int node, int parent, int[] height, int[] vis, Vector<Vector<Integer>> tree)
    {
        // Mark first node as visited
        vis[node] = 1;
      
        // Declare Queue
        Queue<Integer> q = new LinkedList<>();
      
        // Push the first element
        q.add(1);
      
        // Calculate the level of every node
        height[node] = 1 + height[parent];
      
        // Check if the queue is empty or not
        while (q.size() != 0)
        {
             
            // Get the top element in the queue
            int top = (int)q.peek();
      
            // Pop the element
            q.remove();
      
            // Mark as visited
            vis[top] = 1;
      
            // Iterate for the connected nodes
            for(int i = 0; i < tree.get(top).size(); i++)
            {
                 
                // If not visited
                if (vis[(int)tree.get(top).get(i)] == 0)
                {
                     
                    // Insert into queue
                    q.add(tree.get(top).get(i));
      
                    // Increase level
                    height[(int)tree.get(top).get(i)] = 1 + height[top];
                }
            }
        }
    }
      
    // Function to insert edges
    static void insertEdges(int x, int y, Vector<Vector<Integer>> tree)
    {
        tree.get(x).add(y);
        tree.get(y).add(x);
    }
      
    // Function to print all levels
    static void printLevelsOddEven(int N, int[] vis, int[] height)
    {
        int[] mark = new int[N + 1];
        for(int i = 0; i < N + 1; i++)
        {
            mark[i] = 0;
        }
      
        int maxLevel = 0;
        for(int i = 1; i <= N; i++)
        {
             
            // Count number of nodes
            // in every level
            if (vis[i]!=0)
                mark[height[i]]++;
      
            // Find the maximum height of tree
            maxLevel = Math.max(height[i], maxLevel);
        }
      
        // Print odd number of nodes
        System.out.print("The levels with odd " +
                      "number of nodes are: ");
         
        for(int i = 1; i <= maxLevel; i++)
        {
            if (mark[i] % 2 != 0)
            {
                System.out.print(i + " ");
            }
        }
      
        // print even number of nodes
        System.out.println();
        System.out.print("The levels with even " +
                      "number of nodes are: ");
         
        for(int i = 1; i <= maxLevel; i++)
        {
            if (mark[i] % 2 == 0)
            {
                System.out.print(i + " ");
            }
        }
    }

    public static void main(String[] args) {
        // Construct the tree
     
        /*   1
           /   \
          2     3
         / \     \
        4    5    6
            / \  /
           7   8 9  */
         
        int N = 9;
         
        Vector<Vector<Integer>> tree = new Vector<Vector<Integer>>();
         
        for(int i = 0; i < N + 1; i++)
        {
            tree.add(new Vector<Integer>());
        }
         
        insertEdges(1, 2, tree);
        insertEdges(1, 3, tree);
        insertEdges(2, 4, tree);
        insertEdges(2, 5, tree);
        insertEdges(5, 7, tree);
        insertEdges(5, 8, tree);
        insertEdges(3, 6, tree);
        insertEdges(6, 9, tree);
         
        int[] height = new int[N + 1];
        int[] vis = new int[N + 1];
        for(int i = 0; i < N + 1; i++)
        {
            vis[i] = 0;
        }
         
        height[0] = 0;
         
        // Call the bfs function
        bfs(1, 0, height, vis, tree);
         
        // Function to print
        printLevelsOddEven(N, vis, height);
    }
}

// This code is contributed by divyeshrabadiya07.