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

public class BinaryTree<T> : IEnumerable<T> where T : IComparable<T>
{
        class Node<TValue>
        {
                public TValue Value { get; set; }
                public Node<TValue> Left { get; set; }
                public Node<TValue> Right { get; set; }
 
                public Node(TValue value)
                {
                        Value = value;
                }
        }
 
        private Node<T> root;
 
        public BinaryTree() { }
        public BinaryTree(IEnumerable<T> collection)
        {
                AddRange(collection);
        }
 
        public int Count { get; private set; }
        public T Min
        {
                get
                {
                        if (root == null) throw new InvalidOperationException("Tree is empty");
                        var current = root;
                        while (current.Left != null)
                                current = current.Left;
                        return current.Value;
                }
        }
        public T Max
        {
                get
                {
                        if (root == null) throw new InvalidOperationException("Tree is empty");
                        var current = root;
                        while (current.Right != null)
                                current = current.Right;
                        return current.Value;
                }
        }
 
        public void Add(T value)
        {
                if (value == null) throw new ArgumentNullException("value");
 
                var node = new Node<T>(value);
 
                if (root == null)
                        root = node;
                else {
                        Node<T> current = root, parent = null;
 
                        while (current != null) {
                                parent = current;
                                if (value.CompareTo(current.Value) < 0) current = current.Left;
                                else current = current.Right;
                        }
 
                        if (value.CompareTo(parent.Value) < 0) parent.Left = node;
                        else parent.Right = node;
                }
                ++Count;
        }
        public void AddRange(IEnumerable<T> collection)
        {
                foreach (var value in collection)
                        Add(value);
        }
        public void Remove(T value)
        {
                if (value == null) throw new ArgumentNullException("value");
                if (root == null) return;
 
                Node<T> current = root, parent = null;
 
                int result;
                do {
                        result = value.CompareTo(current.Value);
                        if (result < 0) { parent = current; current = current.Left; }
                        else if (result > 0) { parent = current; current = current.Right; }
                        if (current == null) return;
                }
                while (result != 0);
 
                if (current.Right == null) {
                        if (current == root) root = current.Left;
                        else {
                                result = current.Value.CompareTo(parent.Value);
                                if (result < 0) parent.Left = current.Left;
                                else parent.Right = current.Left;
                        }
                }
                else if (current.Right.Left == null) {
                        current.Right.Left = current.Left;
                        if (current == root) root = current.Right;
                        else {
                                result = current.Value.CompareTo(parent.Value);
                                if (result < 0) parent.Left = current.Right;
                                else parent.Right = current.Right;
                        }
                }
                else {
                        Node<T> min = current.Right.Left, prev = current.Right;
                        while (min.Left != null) {
                                prev = min;
                                min = min.Left;
                        }
                        prev.Left = min.Right;
                        min.Left = current.Left;
                        min.Right = current.Right;
 
                        if (current == root) root = min;
                        else {
                                result = current.Value.CompareTo(parent.Value);
                                if (result < 0) parent.Left = min;
                                else parent.Right = min;
                        }
                }
                --Count;
        }
        public void Clear()
        {
                root = null;
                Count = 0;
        }
        public bool Contains(T value)
        {
                var current = root;
                while (current != null) {
                        var result = value.CompareTo(current.Value);
                        if (result == 0) return true;
                        if (result < 0) current = current.Left;
                        else current = current.Right;
                }
                return false;
        }
 
        public IEnumerable<T> Inorder()
        {
                if (root == null) yield break;
 
                var stack = new Stack<Node<T>>();
                var node = root;
 
                while (stack.Count > 0 || node != null) {
                        if (node == null) {
                                node = stack.Pop();
                                yield return node.Value;
                                node = node.Right;
                        }
                        else {
                                stack.Push(node);
                                node = node.Left;
                        }
                }
        }
        public IEnumerable<T> Preorder()
        {
                if (root == null) yield break;
 
                var stack = new Stack<Node<T>>();
                stack.Push(root);
 
                while (stack.Count > 0) {
                        var node = stack.Pop();
                        yield return node.Value;
                        if (node.Right != null) stack.Push(node.Right);
                        if (node.Left != null) stack.Push(node.Left);
                }
        }
        public IEnumerable<T> Postorder()
        {
                if (root == null) yield break;
 
                var stack = new Stack<Node<T>>();
                var node = root;
 
                while (stack.Count > 0 || node != null) {
                        if (node == null) {
                                node = stack.Pop();
                                if (stack.Count > 0 && node.Right == stack.Peek()) {
                                        stack.Pop();
                                        stack.Push(node);
                                        node = node.Right;
                                }
                                else { yield return node.Value; node = null; }
                        }
                        else {
                                if (node.Right != null) stack.Push(node.Right);
                                stack.Push(node);
                                node = node.Left;
                        }
                }
        }
        public IEnumerable<T> Levelorder()
        {
                if (root == null) yield break;
 
                var queue = new Queue<Node<T>>();
                queue.Enqueue(root);
 
                while (queue.Count > 0) {
                        var node = queue.Dequeue();
                        yield return node.Value;
                        if (node.Left != null) queue.Enqueue(node.Left);
                        if (node.Right != null) queue.Enqueue(node.Right);
                }
        }
 
        public IEnumerator<T> GetEnumerator()
        {
                return Inorder().GetEnumerator();
        }
        IEnumerator IEnumerable.GetEnumerator()
        {
                return GetEnumerator();
        }
}