using System;

​

​

    public class Queue<T>

    {

        public Node<T> first;

        public Node<T> last;

​

​

        public Queue()

        {

            this.first = null;

            this.last = null;

        }

​

        public void Insert(T x)

        {

            Node<T> temp = new Node<T>(x);

            if (first == null)

                first = temp;

            else

                last.setNext(temp);

            last = temp;

        }

​

        public T Remove()

        {

            T x = first.getValue();

            first = first.getNext();

            if (first == null)

                last = null;

            return x;

        }

​

        public T Head()

        {

            return first.getValue();

        }

​

        public bool IsEmpty()

        {

            return first == null;

        }

​

​

    }

​

    public class BinNode<T>

    {

        private T value;

        private BinNode<T> left;

        private BinNode<T> right;

​

        public BinNode(T value)

        {

            this.value = value;

            this.left = null;

            this.right = null;

        }

​

        public BinNode(BinNode<T> left, T value, BinNode<T> right)

        {

            this.value = value;

            this.left = left;

            this.right = right;

        }

​

        public T GetValue()

        {

            return value;

        }

​

​

​

        public BinNode<T> GetLeft()

        {

            return left;

        }

​

        public BinNode<T> GetRight()

        {

            return right;

        }

​

        public void setValue(T value)

        {

            this.value = value;

        }

​

        public void SetLeft(BinNode<T> left)

        {

            this.left = left;

        }

​

​

        public void SetRight(BinNode<T> right)

        {

            this.right = right;

        }

​

        public bool HasLeft()

        {

            return(this.left != null);

        }

​

        public bool HasRight()

        {

            return(this.right != null);

        }

​

        public String toString()

        {

            return "( " + left + " " + value + " " + right + " )";

        }

    }

    public class Node<T>

    {

        private T value;

        private Node<T> next;

​

        public Node(T value)

        {

            this.value = value;

            this.next = null;

        }

​

        public Node(T value, Node<T> next)

        {

            this.value = value;

            this.next = next;

        }

​

        public T getValue()

        {

            return this.value;

        }

​

        public Node<T> getNext()

        {

            return this.next;

        }

​

        public void setValue(T value)

        {

            this.value = value;

        }

​

        public void setNext(Node<T> next)

        {

            this.next = next;

        }

​

        public String toString()

        {

            return this.value + " " ;

        }

    }

​

​

​

​

​

    public class Program

    {

        public static BinNode<int> CreateBinaryTree(int[] values, int index = 0)

        {

            if (index >= values.Length)

            {

                return null;

            }

            BinNode<int> node = new BinNode<int>(values[index]);

            node.SetLeft(CreateBinaryTree(values, 2 * index + 1));

            node.SetRight(CreateBinaryTree(values, 2 * index + 2));

            return node;

        }

        public static int With1(BinNode<int> root)

        {

            if (root == null)

                return 0;

            return With1(root.GetLeft()) + With1(root.GetRight()) + 1;

        }

        public static int With2(BinNode<int> root)

        {

            int a = With1(root);

            int index = 2;

            int round = 1;

            int head = 1;

            while (a > head)

            {

                a = a - head;

                head = (int)(Math.Pow(index, round));

                round++;

            }

            return head;

        }

        public static bool IsTowTimses(int num, int run = 0)

        {

            if (num < run)

                return false;

            if (num == run)

                return true;

            if (run == 0)

                return IsTowTimses(num, 2);

            return IsTowTimses(num, run * 2);

        }

        public static int LeftLayer(BinNode<int> root)

        {

            if (root == null)

                return 0;

            return LeftLayer(root.GetLeft()) + 1;

        }

        public static void PrintBinaryTreeX(BinNode<int> root)

        {

            Queue<BinNode<int>> queue = new Queue<BinNode<int>>();

            queue.Insert(root);

            int index = 1;

        int round = 0;

            while (!queue.IsEmpty())

            {

                BinNode<int> current = queue.Remove();

                string s = "";

                int l = With2(root) * LeftLayer(root);

                for (int i = 0; i < l / Math.Pow(2, round); i++)

                    s = s + " ";

                Console.Write(s + " " + current.GetValue() + " ");

                if (index == (int)(Math.Pow(2, round)))

                {

                    Console.WriteLine(" ");

                    for (int i = 0; i < index; i++)

                        Console.Write(s + "/| ");

                    index = 0;

                    round++;

                    Console.WriteLine(" ");

                }

                index++;

                if (current.GetLeft() != null)

                    queue.Insert(current.GetLeft());

                if (current.GetRight() != null)

                    queue.Insert(current.GetRight());

            }

        }

        public static void Main()

        {

            int[] a = new int[20];

            for (int i = 0; i < a.Length; i++)

                a[i] = i + 1;

            BinNode<int> t = CreateBinaryTree(a);

            PrintBinaryTreeX(t);

        }

    }

​

​

​