public static void PreOrderTraversal(BinaryTreeNode node)
 {
     if (node == null)
         return;
     Debug.Print(node.Value.ToString(CultureInfo.InvariantCulture));
     PreOrderTraversal(node.Left);
     PreOrderTraversal(node.Right);
 }
Ejemplo n.º 2
0
        public void VerifyNodeParent()
        {
            BinaryTreeNode parent = new BinaryTreeNode(0);

            BinaryTreeNode node = new BinaryTreeNode(1, parent);

            Assert.Equal(parent, node.Parent);
        }
Ejemplo n.º 3
0
        public void VerifyNodeData()
        {
            BinaryTreeNode node = new BinaryTreeNode(0);

            Assert.Equal(0, node.Data);
        }
Ejemplo n.º 4
0
        public bool RemoveNode(int data)
        {
            BinaryTreeNode targetNode = SearchNode(data);

            if (targetNode == null)
            {
                return(false);
            }
            else
            {
                BinaryTreeNode tempNode;

                if ((targetNode.LeftNode == null) && (targetNode.RightNode == null))
                {
                    if (targetNode.Parent.LeftNode == targetNode)
                    {
                        targetNode.Parent.LeftNode = null;
                    }
                    else if (targetNode.Parent.RightNode == targetNode)
                    {
                        targetNode.Parent.RightNode = null;
                    }
                }
                else if ((targetNode.LeftNode != null) || (targetNode.RightNode != null))
                {
                    if ((targetNode.LeftNode != null) && (targetNode.RightNode != null))
                    {
                        if (targetNode.Parent.LeftNode == targetNode)
                        {
                            tempNode = GetSmallNode(targetNode.RightNode);
                            RemoveNode(tempNode.Data);
                            targetNode.Data = tempNode.Data;
                        }
                        else if (targetNode.Parent.RightNode == targetNode)
                        {
                            tempNode = GetSmallNode(targetNode.RightNode);
                            RemoveNode(tempNode.Data);
                            targetNode.Data = tempNode.Data;
                        }

                        return(true);
                    }

                    if (targetNode.Parent.LeftNode == targetNode)
                    {
                        if (targetNode.LeftNode != null)
                        {
                            targetNode.Parent.LeftNode = targetNode.LeftNode;
                        }
                        else
                        {
                            targetNode.Parent.LeftNode = targetNode.RightNode;
                        }
                    }
                    else if (targetNode.Parent.RightNode == targetNode)
                    {
                        if (targetNode.LeftNode != null)
                        {
                            targetNode.Parent.RightNode = targetNode.LeftNode;
                        }
                        else
                        {
                            targetNode.Parent.RightNode = targetNode.RightNode;
                        }
                    }
                }
            }

            return(true);
        }
Ejemplo n.º 5
0
 public BinaryTree(int rootData)
 {
     _rootNode = new BinaryTreeNode(rootData);
 }
Ejemplo n.º 6
0
            public void Delete(int _val)
            {
                BinaryTreeNode curNode = root;

                if (curNode == null)
                {
                    Console.WriteLine("BST is empty!!!");
                }
                else
                {
                    while (true)
                    {
                        if (curNode.val == _val)
                        {
                            if (curNode.left != null)
                            {
                                if (curNode.right != null)
                                {
                                    BinaryTreeNode leftMaxNode = curNode.left;

                                    while (leftMaxNode.right != null)
                                    {
                                        leftMaxNode = leftMaxNode.right;
                                    }

                                    curNode.val = leftMaxNode.val;
                                    if (leftMaxNode.left != null)
                                    {
                                        leftMaxNode.left.parent  = leftMaxNode.parent;
                                        leftMaxNode.parent.right = leftMaxNode.left;
                                    }
                                    else
                                    {
                                        leftMaxNode.parent.right = null;
                                    }
                                }
                                else
                                {
                                    curNode.left.parent = curNode.parent;

                                    if (curNode.parent.left == curNode)
                                    {
                                        curNode.parent.left = curNode.left;
                                    }
                                    else
                                    {
                                        curNode.parent.right = curNode.left;
                                    }
                                }
                            }
                            else
                            {
                                if (curNode.right != null)
                                {
                                    curNode.right.parent = curNode.parent;
                                    if (curNode.parent.left == curNode)
                                    {
                                        curNode.parent.left = curNode.right;
                                    }
                                    else
                                    {
                                        curNode.parent.right = curNode.right;
                                    }
                                }
                                else
                                {
                                    if (curNode.parent.left == curNode)
                                    {
                                        curNode.parent.left = null;
                                    }
                                    else
                                    {
                                        curNode.parent.right = null;
                                    }
                                }
                            }
                            break;
                        }
                        else if (curNode.val > _val)
                        {
                            if (curNode.left == null)
                            {
                                Console.WriteLine(_val + " is not BST!!!");
                                break;
                            }
                            else
                            {
                                curNode = curNode.left;
                            }
                        }
                        else
                        {
                            if (curNode.right == null)
                            {
                                Console.WriteLine(_val + " is not BST!!!");
                                break;
                            }
                            else
                            {
                                curNode = curNode.right;
                            }
                        }
                    }
                }
            }
Ejemplo n.º 7
0
 public void SetRoot(BinaryTreeNode rootNode)
 {
     root = rootNode;
 }
Ejemplo n.º 8
0
        static void Main(string[] args)
        {
            // travels binary tree
            BinaryTreeNode tmpNode1 = new BinaryTreeNode(1);
            BinaryTreeNode tmpNode2 = new BinaryTreeNode(2);
            BinaryTreeNode tmpNode3 = new BinaryTreeNode(3);
            BinaryTreeNode tmpNode4 = new BinaryTreeNode(4);
            BinaryTreeNode tmpNode5 = new BinaryTreeNode(5);
            BinaryTreeNode tmpNode6 = new BinaryTreeNode(6);
            BinaryTreeNode tmpNode7 = new BinaryTreeNode(7);

            BinaryTree bTree = new BinaryTree();

            bTree.SetRoot(tmpNode1);
            bTree.Insert(tmpNode1, tmpNode2, tmpNode3);
            bTree.Insert(tmpNode2, tmpNode4, tmpNode5);
            bTree.Insert(tmpNode3, tmpNode6, tmpNode7);

            bTree.TravelsByPre();
            Console.WriteLine();

            bTree.TravelsByIn();
            Console.WriteLine();

            bTree.TravelsByPost();
            Console.WriteLine();

            // test heap by link
            HeapByLinked myHeapByLinked = new HeapByLinked();

            myHeapByLinked.Insert(0);
            myHeapByLinked.Insert(1);
            myHeapByLinked.Insert(2);
            myHeapByLinked.Insert(3);
            myHeapByLinked.Insert(4);
            myHeapByLinked.Insert(5);
            myHeapByLinked.Insert(6);


            myHeapByLinked.TravelsByPre();
            Console.WriteLine();

            Console.WriteLine(myHeapByLinked.Delete());
            myHeapByLinked.TravelsByPre();
            Console.WriteLine();

            // test heap by array
            HeapByArray myHeapByArray = new HeapByArray();

            myHeapByArray.Insert(0);
            myHeapByArray.Insert(1);
            myHeapByArray.Insert(2);
            myHeapByArray.Insert(3);
            myHeapByArray.Insert(4);
            myHeapByArray.Insert(5);
            myHeapByArray.Insert(6);

            myHeapByArray.Print();

            Console.WriteLine(myHeapByArray.Delete());
            myHeapByArray.Print();

            //Binary Search Tree
            Console.WriteLine("-----------------");
            Console.WriteLine("It's BST Test!!!");
            BST myBST = new BST();

            myBST.Insert(50);
            myBST.Insert(20);
            myBST.Insert(70);
            myBST.Insert(30);
            myBST.Insert(10);
            myBST.Insert(60);
            myBST.Insert(80);
            myBST.Insert(5);
            myBST.Insert(15);
            myBST.Insert(25);
            myBST.Insert(35);
            myBST.Insert(55);
            myBST.Insert(65);
            myBST.Insert(75);
            myBST.Insert(85);
            myBST.Insert(90);
            myBST.Insert(3);
            myBST.Insert(8);

            myBST.TravelsByIn();
            Console.WriteLine(myBST.Search(4));
            Console.WriteLine(myBST.Search(5));

            myBST.Delete(8);
            myBST.TravelsByIn();

            myBST.Delete(20);
            myBST.TravelsByIn();

            myBST.Delete(4);
            myBST.TravelsByIn();

            //Binary Search Tree derived by Binary Tree
            Console.WriteLine("-----------------");
            Console.WriteLine("It's BST Test!!!");
            BSTDerivedBT myBSTDerived = new BSTDerivedBT();

            myBSTDerived.Insert(50);
            myBSTDerived.Insert(20);
            myBSTDerived.Insert(70);
            myBSTDerived.Insert(30);
            myBSTDerived.Insert(10);
            myBSTDerived.Insert(60);
            myBSTDerived.Insert(80);
            myBSTDerived.Insert(5);
            myBSTDerived.Insert(15);
            myBSTDerived.Insert(25);
            myBSTDerived.Insert(35);
            myBSTDerived.Insert(55);
            myBSTDerived.Insert(65);
            myBSTDerived.Insert(75);
            myBSTDerived.Insert(85);
            myBSTDerived.Insert(90);
            myBSTDerived.Insert(3);
            myBSTDerived.Insert(8);

            myBSTDerived.TravelsByIn();
            Console.WriteLine(myBSTDerived.Search(4));
            Console.WriteLine(myBSTDerived.Search(5));

            myBSTDerived.Delete(8);
            myBSTDerived.TravelsByIn();

            myBSTDerived.Delete(20);
            myBSTDerived.TravelsByIn();

            myBSTDerived.Delete(4);
            myBSTDerived.TravelsByIn();
        }
 /// <summary>
 /// Clears the binary search tree.
 /// </summary>
 public void Clear()
 {
     _root  = null;
     _count = 0;
 }
Ejemplo n.º 10
0
 public BinaryTreeNode(int data, BinaryTreeNode parent)
     : this(data)
 {
     Parent = parent;
 }