Пример #1
0
        /// <summary>
        /// Recursively Visits All nodes in tree applying a given action to all nodes.
        /// By default this method traverses the tree in inorder fashion.
        /// </summary>
        public static void ForEach <T>(BSTNode <T> BinaryTreeRoot, Action <T> Action, TraversalMode Mode = TraversalMode.InOrder) where T : IComparable <T>
        {
            if (BinaryTreeRoot == null)
            {
                throw new ArgumentNullException("Tree root cannot be null.");
            }

            if (Action == null)
            {
                throw new ArgumentNullException("Action<T> Action cannot be null.");
            }

            // Traverse
            switch (Mode)
            {
            case TraversalMode.PreOrder:
                BinaryTreeRecursiveWalker.PreOrderVisitor(BinaryTreeRoot, Action);
                return;

            case TraversalMode.InOrder:
                BinaryTreeRecursiveWalker.InOrderVisitor(BinaryTreeRoot, Action);
                return;

            case TraversalMode.PostOrder:
                BinaryTreeRecursiveWalker.PostOrderVisitor(BinaryTreeRoot, Action);
                return;

            default:
                BinaryTreeRecursiveWalker.InOrderVisitor(BinaryTreeRoot, Action);
                return;
            }
        }
Пример #2
0
        /// <summary>
        /// Private helper method for Preorder Traversal.
        /// </summary>
        private static void PostOrderVisitor <T>(BSTNode <T> BinaryTreeRoot, Action <T> Action) where T : IComparable <T>
        {
            if (BinaryTreeRoot == null)
            {
                return;
            }

            BinaryTreeRecursiveWalker.PostOrderVisitor <T>(BinaryTreeRoot.LeftChild, Action);
            BinaryTreeRecursiveWalker.PostOrderVisitor <T>(BinaryTreeRoot.RightChild, Action);
            Action(BinaryTreeRoot.Value);
        }
Пример #3
0
        /************************************************************************************
         * PUBLIC API SECTION
         *
         */

        /// <summary>
        /// Recusrsivley walks the tree and prints the values of all nodes.
        /// By default this method traverses the tree in inorder fashion.
        /// </summary>
        public static void PrintAll <T>(BSTNode <T> BinaryTreeRoot, TraversalMode Mode = TraversalMode.InOrder) where T : IComparable <T>
        {
            if (BinaryTreeRoot == null)
            {
                throw new ArgumentNullException("Tree root cannot be null.");
            }

            var printAction = new Action <T>((T nodeValue) =>
                                             System.Console.Write(String.Format("{0} ", nodeValue)));

            BinaryTreeRecursiveWalker.ForEach(BinaryTreeRoot, printAction, Mode);
            System.Console.WriteLine();
        }
Пример #4
0
        /// <summary>
        /// Private helper method for Inorder Searcher.
        /// </summary>
        private static bool PostOrderSearcher <T>(BSTNode <T> BinaryTreeRoot, T Value, bool IsBinarySearchTree = false) where T : IComparable <T>
        {
            var current  = BinaryTreeRoot.Value;
            var hasLeft  = BinaryTreeRoot.HasLeftChild;
            var hasRight = BinaryTreeRoot.HasRightChild;

            if (IsBinarySearchTree == true)
            {
                if (hasLeft && current.IsGreaterThan(Value))
                {
                    return(BinaryTreeRecursiveWalker.PostOrderSearcher <T>(BinaryTreeRoot.LeftChild, Value));
                }

                if (hasRight && current.IsLessThan(Value))
                {
                    return(BinaryTreeRecursiveWalker.PostOrderSearcher <T>(BinaryTreeRoot.RightChild, Value));
                }

                if (current.IsEqualTo(Value))
                {
                    return(true);
                }
            }
            else
            {
                if (hasLeft && PostOrderSearcher <T>(BinaryTreeRoot.LeftChild, Value) == true)
                {
                    return(true);
                }

                if (hasRight && PostOrderSearcher <T>(BinaryTreeRoot.RightChild, Value) == true)
                {
                    return(true);
                }

                if (current.IsEqualTo(Value))
                {
                    return(true);
                }
            }

            return(false);
        }
Пример #5
0
        /// <summary>
        /// Search the tree for the specified value.
        /// By default this method traverses the tree in inorder fashion.
        /// </summary>
        public static bool BinarySearch <T>(BSTNode <T> BinaryTreeRoot, T Value, TraversalMode Mode = TraversalMode.InOrder) where T : IComparable <T>
        {
            if (BinaryTreeRoot == null)
            {
                throw new ArgumentNullException("Tree root cannot be null.");
            }

            // Traverse
            // Traverse
            switch (Mode)
            {
            case TraversalMode.PreOrder:
                return(BinaryTreeRecursiveWalker.PreOrderSearcher(BinaryTreeRoot, Value, IsBinarySearchTree: true));

            case TraversalMode.InOrder:
                return(BinaryTreeRecursiveWalker.InOrderSearcher(BinaryTreeRoot, Value, IsBinarySearchTree: true));

            case TraversalMode.PostOrder:
                return(BinaryTreeRecursiveWalker.PostOrderSearcher(BinaryTreeRoot, Value, IsBinarySearchTree: true));

            default:
                return(BinaryTreeRecursiveWalker.InOrderSearcher(BinaryTreeRoot, Value, IsBinarySearchTree: true));
            }
        }