示例#1
0
        public bool Insert(int iKey, Data data)
        {
            if (data == null)
            {
                return false;
            }

            Node n = new Node(iKey,data);

            return Insert(n);
        }
示例#2
0
        public void InOrderTraversal(Node n)
        {
            if (n == null)
            {
                return;
            }

            InOrderTraversal(n.left);
            _visit.VisitNode(n,_que);
            InOrderTraversal(n.right);
        }
示例#3
0
        public void VisitNode(Node n, Queue<int> queue)
        {
            if ((n == null)||(queue == null))
            {
                throw new ArgumentNullException();
            }

            queue.Enqueue(n.iKey);

            return;
        }
        public void VisitNode_Enqueues_Int()
        {
            // Arrange
            Node node = new Node();
            Queue<int> queue = new Queue<int>();
            Visit v = new Visit();  // Class being tested...

            // Act
            Assert.IsTrue(queue.Count == 0);
            v.VisitNode(node, queue);

            //Assert
            Assert.IsTrue(queue.Count == 1);
        }
        public void VisitNode_Throws_ArgumentNullException_On_Null_Queue()
        {
            // Arrange
            Node n = new Node();
            Visit v = new Visit();  // Class being tested...

            // Act/Assert
            try
            {
                v.VisitNode(n, null);
            }
            catch (Exception e)
            {
                Assert.IsTrue(e.GetType() == typeof(ArgumentNullException));
                return;
            }
            Assert.Fail();
        }
示例#6
0
        public bool Insert(Node n)
        {
            if (_tree == null)
            {
                _tree = n;     // tree was empty (null), so n is first element.
                return true;
            }

            Node current = _tree;
            Node parent = null;
            bool inserted = false;

            while (true)
            {
                parent = current;
                if (current.iKey == n.iKey)
                {
                    return true;  // Element (node) is already in tree.
                }

                if (current.iKey > n.iKey)
                {
                    current = current.left;
                    if (current == null)
                    {
                        parent.left = n;  // Less-than insert left.
                        inserted = true;
                        break;
                    }
                }
                else
                {
                    current = current.right;
                    if (current == null)
                    {
                        parent.right = n;
                        inserted = true;
                        break;
                    }
                }
            }

            return inserted;
        }
        public void InOrderTraversal(Node n)
        {
            Stack<Node> s = new Stack<Node>();

            while ((s.Count > 0)||(n != null))
            {
                if (n != null)
                {
                    s.Push(n);
                    n = n.left;
                }
                else  // Get here if (n==null), so stack is not empty.
                {
                    n = s.Pop();
                    _visit.VisitNode(n, _que);
                    n = n.right;
                }
            }
        }
        public void VisitNode_Enqueues_Ints_InOrder()
        {
            // Arrange
            Node node1 = new Node();
            Node node2 = new Node();
            Queue<int> queue = new Queue<int>();
            Visit v = new Visit();  // Class being tested...

            node1.iKey = 1;
            node2.iKey = 2;

            // Act
            v.VisitNode(node1, queue);
            v.VisitNode(node2, queue);

            //Assert
            int i1 = queue.Dequeue();
            int i2 = queue.Dequeue();
            Assert.IsTrue(i1 == 1);
            Assert.IsTrue(i2 == 2);
        }
示例#9
0
        public bool FindNodeAndParent(Node tree, Node n, ref Node parent)
        {
            if (tree == null)    // Check for empty tree.
            {
                parent = null;
                return false;
            }

            if (tree == n)
            {
                return true;
            }

            parent = tree;

            bool found;

            if (tree.iKey > n.iKey)
            {
                if (tree.left != null)
                {
                    found = FindNodeAndParent(tree.left, n, ref parent);
                    if (found == true)
                    {
                        return true;
                    }
                }
            }

            if (tree.right != null)
            {
                found = FindNodeAndParent(tree.right, n, ref parent);
                if (found == true)
                {
                    return true;
                }
            }

            return false;
        }
示例#10
0
        // FindNodeyValue() is a pre-order recursive search. In a well balanced tree this is O(log number-of-nodes).
        private Node FindNodeByValue(Node tree, int iKey)
        {
            if (tree == null)
            {
                return null;
            }

            if (iKey == tree.iKey)  // Check for match.
            {
                return tree;
            }

            if (iKey < tree.iKey)   // Check to see if we need to go look left.
            {
                return FindNodeByValue(tree.left, iKey);
            }

            // Only case left is to check the right branch of the tree.
            return FindNodeByValue(tree.right, iKey);
        }
        public void Test_Remove_On_Node_With_Only_A_Right_Subtree()
        {
            // Arrange
            BinaryTree bt = new BinaryTree();

            Node n1 = new Node(17);
            Node n2 = new Node(23);   // This is the node we will delete.
            Node n3 = new Node(29);

            // This order of insertion should create a right-only subtree.
            bt.Insert(n1);
            bt.Insert(n2);
            bt.Insert(n3);

            // Act
            bool removed = bt.Remove(23);

            // Assert
            Assert.IsTrue(removed);
            Assert.IsTrue(bt.TreeDepth() == 2);
        }
        public void Test_Remove_On_Root_Node_With_Left_and_right_Subtrees()
        {
            // Arrange
            BinaryTree bt = new BinaryTree();

            // The test tree looks like:
            //       11
            //      /  \
            //     5    17
            //    / \
            //   2   7
            //  / \
            // 1   4
            //    /
            //   3
            Node[] nArray = new Node[8];
            nArray[0] = new Node(11);   // This is the node we will delete below (root node).
            nArray[1] = new Node(5);
            nArray[2] = new Node(17);
            nArray[3] = new Node(2);
            nArray[4] = new Node(7);
            nArray[5] = new Node(1);
            nArray[6] = new Node(4);
            nArray[7] = new Node(3);

            // This order of insertion should create a our "complex" tree.
            for (int i = 0; i < 8; i++)
            {
                bt.Insert(nArray[i]);
            }

            // Act
            bool removed = bt.Remove(11);

            // Assert
            Assert.IsTrue(removed);
            Queue<Node> queue = bt.TreeToQueue();  // Get the remaining elements to validate them...
            Assert.IsTrue(queue.Count == 7);
            Assert.IsTrue(1 == queue.Dequeue().iKey);
            Assert.IsTrue(2 == queue.Dequeue().iKey);
            Assert.IsTrue(3 == queue.Dequeue().iKey);
            Assert.IsTrue(4 == queue.Dequeue().iKey);
            Assert.IsTrue(5 == queue.Dequeue().iKey);
            Assert.IsTrue(7 == queue.Dequeue().iKey);
            Assert.IsTrue(17 == queue.Dequeue().iKey);
        }
        public void Test_TreeIsBalanced1_For_Single_Node_Tree()
        {
            // Arrange
            BinaryTree b = new BinaryTree();
            Node tree = new Node();

            // Act
            bool balanced = b.TreeIsBalanced1();

            // Assert
            Assert.IsTrue(balanced);
        }
示例#14
0
        private bool TreeIsBalancedInternal2(Node t, ref int depth)
        {
            if (t == null)
            {
                depth = 0;
                return true;
            }

            int depthL = 0;
            int depthR = 0;

            if (TreeIsBalancedInternal2(t.left,ref depthL)&&(TreeIsBalancedInternal2(t.right,ref depthR)))
            {
                int diff = Math.Abs(depthL - depthR);
                if (diff <= 1)
                {
                    depth = 1 + (Math.Max(depthL, depthR));
                    return true;
                }
            }
            return false;
        }
示例#15
0
        private int TreeDepthInternal(Node t)
        {
            if (t == null)
            {
                return 0;
            }

            int dLeft = TreeDepthInternal(t.left);
            int dRight = TreeDepthInternal(t.right);

            return Math.Max(dLeft, dRight) + 1;  // Plus one for this node...
        }
        public void Test_Remove_On_Node_With_Only_A_Left_Subtree()
        {
            // Arrange
            BinaryTree bt = new BinaryTree();

            Node n1 = new Node(17);
            Node n2 = new Node(14);   // This is the one we will remove.
            Node n3 = new Node(9);

            // This order of insertion should create a left-only subtree.
            bt.Insert(n1);
            bt.Insert(n2);
            bt.Insert(n3);

            // Act
            bool removed = bt.Remove(14);

            // Assert
            Assert.IsTrue(removed);
            Assert.IsTrue(bt.TreeDepth() == 2);
            Queue<Node> queue = bt.TreeToQueue();
            Assert.IsTrue(queue.Dequeue() == n3);
            Assert.IsTrue(queue.Dequeue() == n1);
        }
示例#17
0
        public bool Remove(int iKey)
        {
            Node nRemove = FindNodeByValue(_tree, iKey);  // XXX: Dorky code. Combine this and next method call.
            Node parent = null;
            bool found = FindNodeAndParent(_tree, nRemove, ref parent);

            if (found == false)
            {
                // Either the tree is empty or the node doesn't exist in the tree.
                return false;
            }

            // Ok, node was found.
            if (parent == null)
            {
                // Tree is a single node tree.
                _tree = null;
                return true;
            }

            // Case #1: Node n is a leaf (no children)
            if ( (nRemove.left == null) && (nRemove.right == null))
            {
                if (parent.left == nRemove)
                    parent.left = null;
                else
                    parent.right = null;
                return true;
            }

            // Case #2: Node n has either a left or right child but not both.
            if((nRemove.left != null) && (nRemove.right == null))
            {
                if (parent.left == nRemove)
                {
                    parent.left = nRemove.left;
                }
                else
                {
                    parent.right = nRemove.left;
                }

                return true;
            }

            if ((nRemove.left == null) && (nRemove.right != null))
            {
                if (parent.left == nRemove)
                {
                    parent.left = nRemove.right;
                }
                else
                {
                    parent.right = nRemove.right;
                }

                return true;
            }

            // Case #3: The node has both left and right children.
            // Find the largest value in the left subtree, copy its data into the node being "removed" then
            // remove that largest node from the tree (note: it won't have a right subtree).
            Node nLargest = nRemove.left;
            Node nLargestParent = nRemove;
            while (nLargest.right != null)
            {
                nLargestParent = nLargest;
                nLargest = nLargest.right;
            }

            int tempValue = nLargest.iKey;

            bool removed = Remove(nLargest.iKey);

            nRemove.iKey = tempValue;

            return true;
        }
示例#18
0
        public bool TreeIsBalancedInternal1(Node t)
        {
            if (t == null)
            {
                return true;
            }

            int dLeft = TreeDepthInternal(t.left);
            int dRight = TreeDepthInternal(t.right);

            if (Math.Abs(dLeft - dRight) > 1)
            {
                return false;
            }
            else
            {
                return (TreeIsBalancedInternal1(t.left) && (TreeIsBalancedInternal1(t.right)));
            }
        }
示例#19
0
 private void InOrderTreeToQueue(Node t, Queue<Node> queue)
 {
     if (t != null)
     {
         InOrderTreeToQueue(t.left, queue);
         queue.Enqueue(t);
         InOrderTreeToQueue(t.right, queue);
     }
 }
        public void Test_Remove_On_Node_With_Left_and_right_Leaves()
        {
            // Arrange
            BinaryTree bt = new BinaryTree();

            Node n1 = new Node(17);
            Node n2 = new Node(23);   // This is the node we will delete.
            Node n3 = new Node(21);
            Node n4 = new Node(29);

            bt.Insert(n1);
            bt.Insert(n2);  // Node to delete.
            bt.Insert(n3);
            bt.Insert(n4);

            // Act
            bool removed = bt.Remove(23);

            // Assert
            Assert.IsTrue(removed);
            Queue<Node> queue = bt.TreeToQueue();  // To validate the remaining tree nodes.
            Assert.IsTrue(queue.Count == 3);
            Assert.IsTrue(17 == queue.Dequeue().iKey);
            Assert.IsTrue(21 == queue.Dequeue().iKey);
            Assert.IsTrue(29 == queue.Dequeue().iKey);
        }