C# BinarySearchTree.Insert方法代码示例

        public void CanFindSuccessor()
        {
            var tree = new BinarySearchTree<int, int>();
            tree.Insert(new KeyValue<int, int>(1, 2));
            tree.Insert(new KeyValue<int, int>(4, 5));
            tree.Insert(new KeyValue<int, int>(2, 7));

            Assert.AreEqual(7, tree.Successor(1));
            Assert.AreEqual(5, tree.Successor(2));
        }

 private static BinarySearchTree ConstructSampleBST()
 {
     var tree = new BinarySearchTree();
     tree.Insert(5);
     tree.Insert(3);
     tree.Insert(1);
     tree.Insert(4);
     tree.Insert(6);
     return tree;
 }

        public void AfterAddingIncreaseCount()
        {
            var tree = new BinarySearchTree<int, int>();

            tree.Insert(1.AsKeyValue());
            Assert.AreEqual(1, tree.Count);

            tree.Insert(2.AsKeyValue());
            Assert.AreEqual(2, tree.Count);
        }

        public void CanFindPredecessor()
        {
            var tree = new BinarySearchTree<int, int>();
            tree.Insert(new KeyValue<int, int>(1, 2));
            tree.Insert(new KeyValue<int, int>(3, 5));
            tree.Insert(new KeyValue<int, int>(2, 7));

            Assert.AreEqual(2, tree.Predecessor(2));
            Assert.AreEqual(7, tree.Predecessor(3));
        }

    // Define the data structure binary search tree with operations for
    // "adding new element", "searching element" and "deleting elements".
    // Implement the standard methods from System.Object – ToString(), Equals(…), GetHashCode()
    // and the operators for comparison  == and !=.
    // Add and implement the ICloneable interface for deep copy of the tree.
    // Implement IEnumerable<T> to traverse the tree.
    internal static void Main()
    {
        // Create new binary search tree
        BinarySearchTree<string> tree = new BinarySearchTree<string>();

        // Test adding new element
        tree.Insert("Telerik");
        tree.Insert("Google");
        tree.Insert("Microsoft");
        tree.Insert("Facebook");
        tree.Insert("Twitter");

        // Test ToString()
        Console.WriteLine("Tree: {0}", tree);

        // Test searching element
        Console.WriteLine("Tree contains Telerik? -> {0}", tree.Contains("Telerik"));
        Console.WriteLine("Tree contains IBM? -> {0}", tree.Contains("IBM"));

        // Test deleting element
        tree.Remove("Telerik");
        Console.WriteLine("Tree: remove Telerik");
        Console.WriteLine("Tree: {0}", tree);

        // Test GetHashCode
        Console.WriteLine("Tree hash code = {0}", tree.GetHashCode());

        // Test Equals
        var otherTree = new BinarySearchTree<string>();
        otherTree.Insert("Google");
        Console.WriteLine("\nOther tree: {0}", otherTree);
        Console.WriteLine("tree.Equals(otherTree) -> {0}", tree.Equals(otherTree));

        // Test '=='
        Console.WriteLine("Other tree: insert Microsoft, Facebook, Twitter");
        otherTree.Insert("Microsoft");
        otherTree.Insert("Facebook");
        otherTree.Insert("Twitter");
        Console.WriteLine("Other tree: {0}", otherTree);
        Console.WriteLine("tree.Equals(otherTree) -> {0}", tree.Equals(otherTree));

        // Test IEnumerable<T> to traverse the tree
        Console.WriteLine("\nforeach (var node in tree):");
        foreach (var node in tree)
        {
            Console.WriteLine(node);
        }

        // Test deep copy of the tree.
        var treeClone = tree.Clone();
        Console.WriteLine("\ntreeClone: {0}", treeClone);
        tree.Remove("Google");
        Console.WriteLine("Original tree: remove Google");
        Console.WriteLine("treeClone: {0}", treeClone);
    }

        public void CanDeleteFromRightLeaf()
        {
            var tree = new BinarySearchTree<int, int>();
            tree.Insert(1.AsKeyValue());
            tree.Insert(2.AsKeyValue());
            tree.Insert(3.AsKeyValue());

            tree.Delete(3);

            CollectionAssert.AreEqual(new[] {1, 2}, tree.BreadthFirstSearchEnumerator().Select(_ => _.Value).ToList());
        }

        public void CanDeleteFromMiddleWithLeftChild()
        {
            var tree = new BinarySearchTree<int, int>();
            tree.Insert(3.AsKeyValue());
            tree.Insert(2.AsKeyValue());
            tree.Insert(1.AsKeyValue());

            tree.Delete(2);

            CollectionAssert.AreEqual(new[] {3, 1}, tree.BreadthFirstSearchEnumerator().Select(_ => _.Value).ToList());
        }

        public void CanFindElementInComplexTree()
        {
            var tree = new BinarySearchTree<int, int>();
            tree.Insert(new KeyValue<int, int>(1, 2));
            tree.Insert(new KeyValue<int, int>(3, 5));
            tree.Insert(new KeyValue<int, int>(2, 7));

            Assert.AreEqual(2, tree[1]);
            Assert.AreEqual(7, tree[2]);
            Assert.AreEqual(5, tree[3]);
        }

        public void CountInEnumeratorsMustMatchCountInTree()
        {
            var tree = new BinarySearchTree<int, int>();

            tree.Insert(1.AsKeyValue());
            tree.Insert(3.AsKeyValue());
            tree.Insert(2.AsKeyValue());

            Assert.AreEqual(3, tree.BreadthFirstSearchEnumerator().Count());
            Assert.AreEqual(3, tree.DepthFirstSearchEnumerator().Count());
        }

 public void PreOrderTest()
 {
     BinarySearchTree tree = new BinarySearchTree();
     tree.Root = new NodeTree(4);
     tree.Insert(new NodeTree(2));
     tree.Insert(new NodeTree(3));
     tree.Insert(new NodeTree(5));
     tree.Insert(new NodeTree(6));
     tree.Insert(new NodeTree(1));
     Utilities.PreOrder(tree.Root);
     Assert.IsTrue(true); // refactor it so that the traversal data is dumped to an IEnumerable
 }

        public void BinarySearchTests_GetHeight2()
        {
            IBinarySearchTree<int, string> tree = new BinarySearchTree<int, string>();
            tree.Insert(10, "John");
            tree.Insert(5, "Clark");
            tree.Insert(13, "Pitty");
            tree.Insert(17, "Lilly");

            int height = tree.GetHeight();

            Assert.AreEqual(2, height);
        }

        public void BinarySearchTreeTests_LCA()
        {
            IBinarySearchTree<int, string> tree = new BinarySearchTree<int, string>();

            IBinarySearchTreeNode<int, string> john = tree.Insert(10, "John");
            IBinarySearchTreeNode<int, string> clark = tree.Insert(5, "Clark");
            IBinarySearchTreeNode<int, string> pitty = tree.Insert(13, "Pitty");

            IBinarySearchTreeNode<int, string> ancestor = tree.LCA(john, pitty);

            Assert.IsNotNull(ancestor);
            Assert.AreEqual(john, ancestor);
        }

        public void InsertTest()
        {
            var tree = new BinarySearchTree<int>();
            tree.Insert(10);
            Assert.AreEqual(1, tree.Height);
            Assert.IsNotNull(tree.Head);

            tree.Insert(8);
            Assert.AreEqual(2, tree.Height);

            tree.Insert(12);
            Assert.AreEqual(3, tree.Height);
        }

        public void AppearInBinarySerachTreeOrder()
        {
            var tree = new BinarySearchTree<int, int>();
            var element1 = 1.AsKeyValue();
            var element2 = 2.AsKeyValue();
            var element3 = 3.AsKeyValue();
            tree.Insert(element2);
            tree.Insert(element3);
            tree.Insert(element1);

            var elements = tree.BreadthFirstSearchEnumerator();
            Assert.AreEqual(elements.ElementAt(0), element2);
            Assert.AreEqual(elements.ElementAt(1), element1);
            Assert.AreEqual(elements.ElementAt(2), element3);
        }

        public void CanFindMinimumInOneElementTree()
        {
            var tree = new BinarySearchTree<int, int>();
            tree.Insert(1.AsKeyValue());

            Assert.AreEqual(1, tree.Minimum);
        }