Anti Clockwise spiral traversal of a binary tree

// C# implementation of the approach
using System;

class GFG
{

// Binary tree node
public class Node 
{
    public Node left;
    public Node right;
    public int data;

    public Node(int data)
    {
        this.data = data;
        this.left = null;
        this.right = null;
    }
};

// Recursive Function to find height
// of binary tree
static int height( Node root)
{
    // Base condition
    if (root == null)
        return 0;

    // Compute the height of each subtree
    int lheight = height(root.left);
    int rheight = height(root.right);

    // Return the maximum of two
    return Math.Max(1 + lheight, 1 + rheight);
}

// Function to Print Nodes from left to right
static void leftToRight( Node root, int level)
{
    if (root == null)
        return;

    if (level == 1)
        Console.Write( root.data + " ");

    else if (level > 1)
    {
        leftToRight(root.left, level - 1);
        leftToRight(root.right, level - 1);
    }
}

// Function to Print Nodes from right to left
static void rightToLeft( Node root, int level)
{
    if (root == null)
        return;

    if (level == 1)
        Console.Write( root.data + " ");

    else if (level > 1) 
    {
        rightToLeft(root.right, level - 1);
        rightToLeft(root.left, level - 1);
    }
}

// Function to print anti clockwise spiral 
// traversal of a binary tree
static void antiClockWiseSpiral( Node root)
{
    int i = 1;
    int j = height(root);

    // Flag to mark a change in the direction 
    // of printing nodes
    int flag = 0;
    while (i <= j)
    {

        // If flag is zero print nodes
        // from right to left
        if (flag == 0)
        {
            rightToLeft(root, i);

            // Set the value of flag as zero
            // so that nodes are next time 
            // printed from left to right
            flag = 1;

            // Increment i
            i++;
        }

        // If flag is one print nodes
        // from left to right
        else
        {
            leftToRight(root, j);

            // Set the value of flag as zero
            // so that nodes are next time 
            // printed from right to left
            flag = 0;

            // Decrement j
            j--;
        }
    }
}

// Driver code
public static void Main(String []args)
{
    Node root = new Node(1);
    root.left = new Node(2);
    root.right = new Node(3);
    root.left.left = new Node(4);
    root.right.left = new Node(5);
    root.right.right = new Node(7);
    root.left.left.left = new Node(10);
    root.left.left.right = new Node(11);
    root.right.right.left = new Node(8);

    antiClockWiseSpiral(root);

}
}

//This code is contributed by Arnab Kundu

// C# implementation of the above approach
using System;
using System.Collections;
using System.Collections.Generic;

public class GFG {

  // Structure of each node
  class Node {
    public int val;
    public Node left, right;
    public Node(int val)
    {
      this.val = val;
      this.left = this.right = null;
    }
  }

  private void work(Node root)
  {
    // Initialize queue
    Queue q = new Queue();

    // Add the root node
    q.Enqueue(root);

    // Initialize the vector
    List<Node> topone = new List<Node>();

    // Until queue is not empty
    while (q.Count != 0) {
      int len = q.Count;

      // len is greater than zero
      while (len > 0) {
        Node nd = (Node)q.Dequeue();
        if (nd != null) {
          topone.Add(nd);
          if (nd.right != null)
            q.Enqueue(nd.right);
          if (nd.left != null)
            q.Enqueue(nd.left);
        }
        len--;
      }
      topone.Add(null);
    }
    bool top = true;
    int l = 0, r = topone.Count - 2;

    while (l < r) {
      if (top) {
        while (l < topone.Count) {
          Node nd = topone[l++];
          if (nd == null) {
            break;
          }
          Console.Write(nd.val + " ");
        }
      }
      else {
        while (r >= l) {
          Node nd = topone[r--];
          if (nd == null)
            break;
          Console.Write(nd.val + " ");
        }
      }
      top = !top;
    }
  }

  // Build Tree
  public void solve()
  {
    /*
                            1
                         2     3
                       4     5   7
                      10 11     8
                    */

    Node root = new Node(1);
    root.left = new Node(2);
    root.right = new Node(3);
    root.left.left = new Node(4);
    root.right.left = new Node(5);
    root.right.right = new Node(7);
    root.left.left.left = new Node(10);
    root.left.left.right = new Node(11);
    root.right.right.left = new Node(8);

    // Function call
    work(root);
  }

  static public void Main()
  {

    // Code
    GFG t = new GFG();
    t.solve();
  }
}

// This code is contributed by lokeshmvs21.