Обход дерева по уровням рекурсивно

public class Tree
{
    public Tree Left;
    public Tree Right;
    public byte Value;
            
    public Tree(byte val)
    {
        Value = val;
    }
}

static List<byte> TreeWalk(Tree tree)
{
    if (tree == null) return new List<byte>();
    var result = TreeWalk(tree.Left);
    result.Add(tree.Value);
    result.AddRange(TreeWalk(tree.Right));
    return result;
}

//дерево (((null,1,null),2,null),5,(null,7,null))
var tree = new Tree(5)
{
    Left = new Tree(2)
        {
            Left = new Tree(1)
        }, 
    Right = new Tree(7)
};
 
var list = TreeWalk(tree);
//1, 2, 5, 7
Console.WriteLine(String.Join(", ",list.Select(t=>(t.ToString()))));

     5
  2    7
1  3    8

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
 
namespace ConsoleApplication79
{
    public class Tree<T> : IEnumerable<T>
        where T : IComparable<T>
    {
        private const string Pad = ".";
        private T value;
        private Tree<T> left;
        private Tree<T> right;
 
        public Tree(T value)
        {
            this.value = value;
        }
 
        public Tree()
            : this(default(T))
        {
 
        }
 
        public void Add(T element)
        {
            if (Equals(value, default(T)))
                value = element;
            else
                switch (element.CompareTo(value))
                {
                    case -1:
                        if (left == null)
                            left = new Tree<T>(element);
                        else
                            left.Add(element);
                        return;
                    case 1:
                        if (right == null)
                            right = new Tree<T>(element);
                        else
                            right.Add(element);
                        return;
                    default:
                        throw new Exception("Узел уже занят!");
                }
        }
 
        public IEnumerator<T> GetEnumerator()
        {
            if (!Equals(value, default(T)))
                yield return value;
            if (left != null)
                foreach (T elem in left)
                    yield return elem;
            if (right != null)
                foreach (T elem in right)
                    yield return elem;
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
 
        public void Print()
        {
            Print("");
        }
 
        private void Print(string padding)
        {
            if (!Equals(value, default(T)))
                Console.WriteLine(padding + value);
            padding += Pad;
            if (left != null)
                left.Print(padding);
            if (right != null)
                right.Print(padding);
        }
 
        public int Count
        {
            get
            {
                return this.Count();
            }
        }
    }
 
    public class Program
    {
        private static void Main()
        {
            Console.WriteLine("");
            Console.WriteLine("Бинарное дерево:");
            Console.WriteLine("");
            var t = new Tree<string> {"33", "9", "5", "3", "1"};
            t.Print();
            Console.ReadKey();
        }
    }
}

class BinaryTree<T> : IEnumerable<T>
{
    class Node
    {
        public Node Left { get; set; }
        public Node Right { get; set; }
        public T Value { get; set; }
 
        public Node(T value)
        {
            this.Value = value;
        }
    }
    private IComparer<T> comparer;
    private Node root;
 
    public int Count { get; private set; }
 
    public BinaryTree()
        : this(Comparer<T>.Default)
    {
 
    }
    public BinaryTree(IComparer<T> comparer)
    {
        if (comparer == null)
            throw new ArgumentNullException("comparer");
 
        this.comparer = comparer;
    }
 
    public void Add(T value)
    {
        var node = new Node(value);
 
        if (root == null)
            root = node;
        else
        {
            Node current = root, parent = null;
 
            while (current != null)
            {
                parent = current;
                if (comparer.Compare(value, current.Value) < 0)
                    current = current.Left;
                else
                    current = current.Right;
            }
 
            if (comparer.Compare(value, parent.Value) < 0)
                parent.Left = node;
            else
                parent.Right = node;
        }
        Count++;
    }
 
    private int GetHeight(Node root)
    {
        if (root == null)
            return 0;
 
        return Math.Max(GetHeight(root.Left), GetHeight(root.Right)) + 1;
    }
 
    private IEnumerable<T> TraverseLevel(Node root, int level)
    {
        if (root == null)
            yield break;
        if (level == 0)
            yield return root.Value;
        else
        {
            foreach (var value in TraverseLevel(root.Left, level - 1)) yield return value;
            foreach (var value in TraverseLevel(root.Right, level - 1)) yield return value;
        }
    }
 
    public IEnumerator<T> GetEnumerator()
    {
        int height = GetHeight(root);
 
        for (int i = 0; i < height; i++)
        {
            foreach (var value in TraverseLevel(root, i))
                yield return value;
        }
    }
 
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

static void Main()
{
    var tree = new BinaryTree<int> { 8, 4, 2, 6, 1, 3, 5, 7, 12, 10, 9, 11, 14, 13, 15 };
 
    foreach (var value in tree)
        Console.Write("{0} ", value);
    Console.WriteLine();
}