Anti Clockwise spiral traversal of a binary tree?

Here we will see one interesting problem. We have a binary tree and we have to traverse it in an anti-clockwise manner. The traversal alternates between printing levels from right-to-left (starting from the top) and left-to-right (starting from the bottom), creating a spiral-like anti-clockwise pattern.

For the binary tree shown below, the anti-clockwise traversal sequence is − 1, 8, 9, 10, 11, 12, 13, 14, 15, 3, 2, 4, 5, 6, 7

How It Works

The traversal uses two pointers ? i starting from the top level and j starting from the bottom level. A flag alternates between the two directions −

• When flag = false − print level i from right to left, then move i down.

• When flag = true − print level j from left to right, then move j up.

This continues until i and j cross each other.

Traversal Order

Algorithm

antiClockTraverse(root)

Begin
   i := 1, j := height of the tree
   flag := false
   while i <= j, do
      if flag is false, then
         print tree elements from right to left for level i
         flag := true
         i := i + 1
      else
         print tree elements from left to right for level j
         flag := false
         j := j - 1
      end if
   done
End

Example

Following is the C++ implementation of anti-clockwise binary tree traversal −

#include <iostream>
using namespace std;

class Node {
   public:
      Node* left;
      Node* right;
      int data;
   Node(int data) {
      this->data = data;
      this->left = NULL;
      this->right = NULL;
   }
};

int getHeight(Node* root) {
   if (root == NULL)
      return 0;
   int hl = getHeight(root->left);
   int hr = getHeight(root->right);
   return 1 + max(hl, hr);
}

void printLeftToRight(Node* root, int level) {
   if (root == NULL)
      return;
   if (level == 1)
      cout << root->data << " ";
   else if (level > 1) {
      printLeftToRight(root->left, level - 1);
      printLeftToRight(root->right, level - 1);
   }
}

void printRightToLeft(Node* root, int level) {
   if (root == NULL)
      return;
   if (level == 1)
      cout << root->data << " ";
   else if (level > 1) {
      printRightToLeft(root->right, level - 1);
      printRightToLeft(root->left, level - 1);
   }
}

void antiClockTraverse(Node* root) {
   int i = 1;
   int j = getHeight(root);
   int flag = 0;
   while (i <= j) {
      if (flag == 0) {
         printRightToLeft(root, i);
         flag = 1;
         i++;
      } else {
         printLeftToRight(root, j);
         flag = 0;
         j--;
      }
   }
}

int main() {
   Node* root = new Node(1);
   root->left = new Node(2);
   root->right = new Node(3);
   root->left->left = new Node(4);
   root->left->right = new Node(5);
   root->right->left = new Node(6);
   root->right->right = new Node(7);
   root->left->left->left = new Node(8);
   root->left->left->right = new Node(9);
   root->left->right->left = new Node(10);
   root->left->right->right = new Node(11);
   root->right->left->left = new Node(12);
   root->right->left->right = new Node(13);
   root->right->right->left = new Node(14);
   root->right->right->right = new Node(15);

   cout << "Anti-clockwise traversal: ";
   antiClockTraverse(root);
   return 0;
}

The output of the above code is −

Anti-clockwise traversal: 1 8 9 10 11 12 13 14 15 3 2 4 5 6 7

Conclusion

Anti-clockwise traversal of a binary tree alternates between printing top levels right-to-left and bottom levels left-to-right, creating a spiral pattern. The algorithm uses two level pointers moving inward from opposite ends and a flag to alternate direction. The time complexity is O(n²) due to repeated level-order printing, where n is the number of nodes.