How to keep track of layers when traversing a binary tree?

Question

If I need to print out each elements of a binary tree constructed with the struct below. How could I keep track of which layer of elements I am printing? struct for a binary tree node

For example: any binary tree

Expected output: layer 0: 12 layer -1: 28 19 layer -2: 94 32 layer -3: 65 18 72

Answer 1

Solution using queue based on GeeksForGeeks

#include <iostream>
#include <queue>

using namespace std;

// A Binary Tree Node

struct node
{
    struct node *left;

    int data;

    struct node *right;
};

// Iterative method to do level order traversal
// line by line

void printLevelOrder(node *root)
{
    // Base Case

    if (root == NULL)
        return;

    // Create an empty queue for level order tarversal

    queue<node *> q;

    // Enqueue Root and initialize height

    q.push(root);

    int i = 0;

    while (q.empty() == false)

    {
        cout << "layer " << i << ": ";

        // nodeCount (queue size) indicates number

        // of nodes at current lelvel.

        int nodeCount = q.size();

        // Dequeue all nodes of current level and

        // Enqueue all nodes of next level

        while (nodeCount > 0)

        {
            node *node = q.front();

            cout << node->data << " ";

            q.pop();

            if (node->left != NULL)

                q.push(node->left);

            if (node->right != NULL)

                q.push(node->right);

            nodeCount--;
        }

        cout << endl;
        --i;
    }
}

// Utility function to create a new tree node

node *newNode(int data)
{
    node *temp = new node;

    temp->data = data;

    temp->left = NULL;

    temp->right = NULL;

    return temp;
}

// Driver program to test above functions

int main()
{
    // Create binary tree

    node *root = newNode(12);

    root->left = newNode(28);

    root->right = newNode(19);

    root->left->left = newNode(94);

    root->left->left->left = newNode(65);

    root->left->left->right = newNode(18);

    root->right->left = newNode(32);

    root->right->left->right = newNode(72);

    printLevelOrder(root);

    return 0;
}

Solution using recursive function and helper function based on CrazyForCode:

#include <iostream>
using namespace std;

struct node
{
    int data;
    struct node *left;
    struct node *right;
};

void printLevel(node *, int);
int height(struct node *node);

/* Function to print level order traversal a tree*/
void printLevelOrder(struct node *root)
{
    int h = height(root);
    int i;
    for (i = 1; i <= h; i++){
        printf("layer %d: ",i*-1+1);
        printLevel(root, i);
        cout << endl;
    }
}

/* Print nodes at a given level */
void printLevel(struct node *root, int level)
{
    if (root == NULL)
        return;
    if (level == 1)
    {
        printf("%d ", root->data);
    }
    else if (level > 1)
    {
        printLevel(root->left, level - 1);
        printLevel(root->right, level - 1);
    }
}

/* Compute the "height" of a tree */
int height(struct node *node)
{
    if (node == NULL)
        return 0;
    else
    {
        int lheight = height(node->left);
        int rheight = height(node->right);

        if (lheight > rheight)
            return (lheight + 1);
        else
            return (rheight + 1);
    }
}

node *newNode(int data)
{
    node *temp = new node;

    temp->data = data;

    temp->left = NULL;

    temp->right = NULL;

    return temp;
}

int main()
{
    // Create binary tree

    node *root = newNode(12);

    root->left = newNode(28);

    root->right = newNode(19);

    root->left->left = newNode(94);

    root->left->left->left = newNode(65);

    root->left->left->right = newNode(18);

    root->right->left = newNode(32);

    root->right->left->right = newNode(72);

    printLevelOrder(root);

    return 0;
}