public void FiveNodeSplayTest() { IEnumerable <long> preOrderList = new List <long>() { 5, 4, 3, 2, 1, -1, -1, -1, -1, -1, -1 }; var root = BST.ParseBST(ref preOrderList); var st = new SplayTree(root); Assert.AreEqual("5(4(3(2(1,-),-),-),-)", st.ToString()); st.Splay(1); Assert.AreEqual("1(-,4(2(-,3),5))", st.ToString()); st.Splay(3); Assert.AreEqual("3(1(-,2),4(-,5))", st.ToString()); st.Splay(2); Assert.AreEqual("2(1,3(-,4(-,5)))", st.ToString()); st.Splay(4); Assert.AreEqual("4(3(2(1,-),-),5)", st.ToString()); st.Splay(4); Assert.AreEqual("4(3(2(1,-),-),5)", st.ToString()); st.Splay(2); st.Splay(4); Assert.AreEqual("4(3(2(1,-),-),5)", st.ToString()); }
public void InsertTest() { IEnumerable <long> preOrderList = new List <long>() { 30, 20, 10, -1, -1, -1, -1 }; var root = BST.ParseBST(ref preOrderList); var st = new SplayTree(root); Assert.AreEqual("30(20(10,-),-)", st.ToString()); st.Insert(15); Assert.AreEqual("15(10,30(20,-))", st.ToString()); st.Insert(25); Assert.AreEqual("25(15(10,20),30)", st.ToString()); st.Insert(23); Assert.AreEqual("23(20(15(10,-),-),25(-,30))", st.ToString()); st.Insert(17); Assert.AreEqual("17(15(10,-),23(20,25(-,30)))", st.ToString()); st.Insert(21); Assert.AreEqual("21(17(15(10,-),20),23(-,25(-,30)))", st.ToString()); st.Insert(35); Assert.AreEqual("35(23(21(17(15(10,-),20),-),30(25,-)),-)", st.ToString()); st.Insert(5); Assert.AreEqual("5(-,23(17(10(-,15),21(20,-)),35(30(25,-),-)))", st.ToString()); }
public void ThreeNodeSplayTest() { IEnumerable <long> preOrderList = new List <long>() { 3, 2, 1, -1, -1, -1, -1 }; var root = BST.ParseBST(ref preOrderList); var st = new SplayTree(root); Assert.AreEqual("3(2(1,-),-)", st.ToString()); st.Splay(1); Assert.AreEqual("1(-,2(-,3))", st.ToString()); st.Splay(3); Assert.AreEqual("3(2(1,-),-)", st.ToString()); st.Splay(2); Assert.AreEqual("2(1,3)", st.ToString()); st.Splay(3); Assert.AreEqual("3(2(1,-),-)", st.ToString()); st.Splay(3); Assert.AreEqual("3(2(1,-),-)", st.ToString()); }
public void Simple2() { var splayTree = new SplayTree <int, string>(); var dictionary = new Dictionary <int, string>(); var rand = new Random(Convert.ToInt32(DateTime.Now.Ticks % Int32.MaxValue)); for (var i = 0; i < 50; i++) { var gen = rand.Next(2000); while (dictionary.ContainsKey(gen)) { gen = rand.Next(2000); } dictionary.Add(gen, null); splayTree.Add(gen, gen.ToString()); Assert.AreEqual(splayTree.Count, i + 1); Assert.IsTrue(splayTree.ContainsKey(gen)); } using (var enumerator = dictionary.GetEnumerator()) { while (enumerator.MoveNext()) { Assert.IsTrue(splayTree.Remove(enumerator.Current)); } } }
private static void Main() { var splay = new SplayTree <int>(); splay.Insert(3); splay.Preorder(); splay.Insert(5); splay.Preorder(); splay.Insert(7); splay.Preorder(); splay.Insert(6); splay.Preorder(); splay.Find(3); splay.Preorder(); splay.Insert(1); splay.Preorder(); splay.Remove(6); splay.Preorder(); splay.Find(3); splay.Preorder(); splay.Insert(10); splay.Insert(2); splay.Preorder(); Console.ReadKey(); }
public void Add() { SplayTree <int, string> tree = new SplayTree <int, string>(); var a = tree.Add(10, "a"); var b = tree.Add(5, "b"); Assert.IsTrue(b == tree.Root); Assert.IsTrue(b.Right == a); var c = tree.Add(7, "c"); Assert.IsTrue(c == tree.Root); Assert.IsTrue(c.Left == b); Assert.IsTrue(c.Right == a); var d = tree.Add(3, "d"); Assert.IsTrue(d == tree.Root); Assert.IsTrue(d.Left == null); Assert.IsTrue(d.Right == b); Assert.IsTrue(b.Left == null); Assert.IsTrue(b.Right == c); Assert.IsTrue(c.Right == a); Assert.IsTrue(c.Left == null); }
public void SplayTreeRemoveMediumTree() { var tree = new SplayTree <int, string> { { 1, "1" }, { 2, "2" }, { 3, "3" } }; Assert.IsTrue(tree.Remove(2)); Assert.AreEqual(tree.Count, 2); Assert.IsTrue(tree.Root.HasValue); var root = tree.Root.Value; Assert.AreEqual(root.Value, "1"); Assert.IsFalse(root.Parent.HasValue); Assert.IsTrue(root.Right.HasValue); Assert.IsFalse(root.Left.HasValue); var right = root.Right.Value; Assert.AreEqual(right.Value, "3"); Assert.IsTrue(right.Parent.HasValue); Assert.AreEqual(right.Parent.Value.Value, "1"); Assert.IsFalse(right.Left.HasValue); Assert.IsFalse(right.Right.HasValue); }
public void NonIComparable() { var splayTree = new SplayTree <NonComparableTClass, string> { { new NonComparableTClass(4), "4" }, { new NonComparableTClass(6), "6" }, { new NonComparableTClass(2), "2" }, { new NonComparableTClass(5), "5" }, { new NonComparableTClass(19), "19" }, { new NonComparableTClass(1), "1" } }; var newTree = SerializeUtil.BinarySerializeDeserialize(splayTree); Assert.AreNotSame(splayTree, newTree); Assert.AreEqual(splayTree.Count, newTree.Count); var splayTreeEnumerator = splayTree.GetEnumerator(); var newTreeEnumerator = newTree.GetEnumerator(); while (splayTreeEnumerator.MoveNext()) { Assert.IsTrue(newTreeEnumerator.MoveNext()); Assert.AreEqual(splayTreeEnumerator.Current.Key.Number, newTreeEnumerator.Current.Key.Number); Assert.AreEqual(splayTreeEnumerator.Current.Value, newTreeEnumerator.Current.Value); //TODO: Need a way of accessing an item without splaying //Assert.AreEqual(newTree.ContainsKey(splayTreeEnumerator.Current.Key)); //Assert.AreEqual(newTree[treeEnumerator.Current.Key], splayTreeEnumerator.Current.Value); } Assert.IsFalse(newTreeEnumerator.MoveNext()); }
public void Add() { SplayTree<int, string> tree = new SplayTree<int, string>(); var a = tree.Add(10, "a"); var b = tree.Add(5, "b"); Assert.IsTrue(b == tree.Root); Assert.IsTrue(b.Right == a); var c = tree.Add(7, "c"); Assert.IsTrue(c == tree.Root); Assert.IsTrue(c.Left == b); Assert.IsTrue(c.Right == a); var d = tree.Add(3, "d"); Assert.IsTrue(d == tree.Root); Assert.IsTrue(d.Left == null); Assert.IsTrue(d.Right == b); Assert.IsTrue(b.Left == null); Assert.IsTrue(b.Right == c); Assert.IsTrue(c.Right == a); Assert.IsTrue(c.Left == null); }
public void KeyValuePair() { var splayTree = new SplayTree<int, string> { {4, "4"}, {6, "6"}, {2, "2"}, {5, "5"}, {19, "19"}, {1, "1"} }; Assert.AreEqual(splayTree.Count, 6); Assert.IsTrue(splayTree.ContainsKey(4)); Assert.IsTrue(splayTree.ContainsKey(6)); Assert.IsTrue(splayTree.ContainsKey(2)); Assert.IsTrue(splayTree.ContainsKey(5)); Assert.IsTrue(splayTree.ContainsKey(19)); Assert.IsTrue(splayTree.ContainsKey(1)); Assert.IsFalse(splayTree.Remove(new KeyValuePair<int, string>(20, "20"))); Assert.IsTrue(splayTree.Remove(new KeyValuePair<int, string>(4, "4"))); Assert.AreEqual(splayTree.Count, 5); Assert.IsFalse(splayTree.ContainsKey(4)); Assert.IsTrue(splayTree.ContainsKey(6)); Assert.IsTrue(splayTree.ContainsKey(2)); Assert.IsTrue(splayTree.ContainsKey(5)); Assert.IsTrue(splayTree.ContainsKey(19)); Assert.IsTrue(splayTree.ContainsKey(1)); }
public void KeyValuePair() { var splayTree = new SplayTree <int, string>(); var dictionary = new Dictionary <int, string>(); var rand = new Random(Convert.ToInt32(DateTime.Now.Ticks % Int32.MaxValue)); for (var i = 0; i < 50; i++) { var gen = rand.Next(2000); while (dictionary.ContainsKey(gen)) { gen = rand.Next(2000); } dictionary.Add(gen, null); splayTree.Add(new KeyValuePair <int, string>(gen, gen.ToString())); Assert.AreEqual(splayTree.Count, i + 1); Assert.IsTrue(splayTree.ContainsKey(gen)); } }
public void ExceptionEmpty() { var splayTree = new SplayTree <int, string>(); KeyValuePair <int, string> i; Assert.Throws <InvalidOperationException>(() => i = splayTree.Maximum); }
public void TestChainFind() { var t = new SplayTree <ulong>(); t.Root = createNode(7); t.Root.Left = createNode(6); t.Root.Left.Left = createNode(5); t.Root.Left.Left.Left = createNode(4); t.Root.Left.Left.Left.Left = createNode(3); t.Root.Left.Left.Left.Left.Left = createNode(2); t.Root.Left.Left.Left.Left.Left.Left = createNode(1); t.Root.Left.Parent = t.Root; t.Root.Left.Left.Parent = t.Root.Left; t.Root.Left.Left.Left.Parent = t.Root.Left.Left; t.Root.Left.Left.Left.Left.Parent = t.Root.Left.Left.Left; t.Root.Left.Left.Left.Left.Left.Parent = t.Root.Left.Left.Left.Left; t.Root.Left.Left.Left.Left.Left.Left.Parent = t.Root.Left.Left.Left.Left.Left; Assert.AreEqual("[7] [6] [5] [4] [3] [2] [1] ", t.ToString()); t.Find(1); Assert.AreEqual("[1] [6] [4] [7] [2] [5] [3] ", t.ToString()); }
public static void main(String[] args) { for (int i = 0; i <= 20; i++) { SplayTree t = new SplayTree(); int n = (int)Math.Pow(2, i); // number of elements at max size long m = 3 * n; // number of operations (insert + lookup) long T = 0; // number of single rotations if (n > Int32.MaxValue) { throw new Exception(); } for (int m1 = 0; m1 < n; m1++) { t.Insert(m1); } lookupRand(t, n, m); lookupRand(t, n, m); T = t.NumRotations; double tm = (double)T / m; // T / m double ln = Math.Log(n) / Math.Log(2); // log_2(n) Console.WriteLine(i + ": "); Console.WriteLine(String.Format("({0}, {1})", ln, tm)); } }
static void SplayTreeTest() { SplayTree <int> impl = new SplayTree <int>(); impl.add(17); impl.add(39); impl.add(22); impl.add(42); impl.add(70); impl.add(64); impl.add(84); impl.add(99); Console.WriteLine("Preorder after insert: " + impl); Console.WriteLine("Leave counts: " + impl.leafCount(impl.getRoot())); Console.WriteLine("Leave counts: " + impl.leafSum(impl.getRoot())); impl.remove(22); Console.WriteLine("After delete preorder: " + impl); Console.WriteLine("Node found or not: " + impl.contains(42)); Console.WriteLine("After search preorder: " + impl); Console.WriteLine("Node found or not: " + impl.contains(98)); Console.WriteLine("After search preorder: " + impl); }
public void Splay_ZigZag() { var arr = new int[] { 7, 4, 3, 5, 1, 8 }; var tree = new SplayTree <int>(); foreach (var e in arr) { tree.Insert(e); } tree.Splay(tree.root.Left.Right); Assert.AreEqual(7, tree.root.Value); Assert.AreEqual(3, tree.root.Left.Value); Assert.AreEqual(1, tree.root.Left.Left.Value); Assert.AreEqual(5, tree.root.Left.Right.Value); Assert.AreEqual(4, tree.root.Left.Right.Left.Value); Assert.AreEqual(8, tree.root.Right.Value); tree.Splay(tree.root.Left.Right.Left); Assert.AreEqual(4, tree.root.Value); Assert.AreEqual(3, tree.root.Left.Value); Assert.AreEqual(1, tree.root.Left.Left.Value); Assert.AreEqual(7, tree.root.Right.Value); Assert.AreEqual(8, tree.root.Right.Right.Value); Assert.AreEqual(5, tree.root.Right.Left.Value); }
public void Simple() { var splayTree = new SplayTree <int, string>(); var dictionary = new Dictionary <int, string>(); var rand = new Random(Convert.ToInt32(DateTime.Now.Ticks % Int32.MaxValue)); for (var i = 0; i < 50; i++) { var gen = rand.Next(2000); while (dictionary.ContainsKey(gen)) { gen = rand.Next(2000); } dictionary.Add(gen, null); splayTree.Add(gen, gen.ToString()); string val; Assert.AreEqual(splayTree.Count, i + 1); splayTree.TryGetValue(gen, out val); Assert.AreEqual(val, gen.ToString()); Assert.AreEqual(splayTree[gen], gen.ToString()); } string val2; splayTree.TryGetValue(2001, out val2); Assert.IsNull(val2); }
public void ExceptionInvalidIndexerGet() { var splayTree = new SplayTree <int, string>(); string value; Assert.Throws <KeyNotFoundException>(() => value = splayTree[4]); }
public void FindDeletedKeyTest() { SplayTree <int, int> t = new SplayTree <int, int>(); HashSet <int> addedKeys = new HashSet <int>(); foreach (int i in Enumerable.Range(0, 100)) { int key = this._Rand.Next(); addedKeys.Add(key); t.Add(key, this._Rand.Next()); } foreach (var key in addedKeys) { t.Remove(key); Exception ex = null; try { t.Find(key); } catch (Exception innerEx) { ex = innerEx; } Assert.IsInstanceOfType(ex, typeof(KeyNotFoundException)); } }
public void KeyValuePair() { var splayTree = new SplayTree <int, string> { { 4, "4" }, { 6, "6" }, { 2, "2" }, { 5, "5" }, { 19, "19" }, { 1, "1" } }; Assert.AreEqual(splayTree.Count, 6); Assert.IsTrue(splayTree.ContainsKey(4)); Assert.IsTrue(splayTree.ContainsKey(6)); Assert.IsTrue(splayTree.ContainsKey(2)); Assert.IsTrue(splayTree.ContainsKey(5)); Assert.IsTrue(splayTree.ContainsKey(19)); Assert.IsTrue(splayTree.ContainsKey(1)); Assert.IsFalse(splayTree.Remove(new KeyValuePair <int, string>(20, "20"))); Assert.IsTrue(splayTree.Remove(new KeyValuePair <int, string>(4, "4"))); Assert.AreEqual(splayTree.Count, 5); Assert.IsFalse(splayTree.ContainsKey(4)); Assert.IsTrue(splayTree.ContainsKey(6)); Assert.IsTrue(splayTree.ContainsKey(2)); Assert.IsTrue(splayTree.ContainsKey(5)); Assert.IsTrue(splayTree.ContainsKey(19)); Assert.IsTrue(splayTree.ContainsKey(1)); }
public void SplayTree_StressTest() { var nodeCount = 1000 * 10; var rnd = new Random(); var randomNumbers = Enumerable.Range(1, nodeCount) .OrderBy(x => rnd.Next()) .ToList(); var tree = new SplayTree <int>(); for (int i = 0; i < nodeCount; i++) { tree.Insert(randomNumbers[i]); Assert.IsTrue(tree.Count == i + 1); } //shuffle again before deletion tests randomNumbers = Enumerable.Range(1, nodeCount) .OrderBy(x => rnd.Next()) .ToList(); for (int i = 0; i < nodeCount; i++) { tree.Delete(randomNumbers[i]); Assert.IsTrue(tree.Count == nodeCount - 1 - i); } Assert.IsTrue(tree.Count == 0); }
public void NonIComparable() { var splayTree = new SplayTree<NonComparableTClass, string> { {new NonComparableTClass(4), "4"}, {new NonComparableTClass(6), "6"}, {new NonComparableTClass(2), "2"}, {new NonComparableTClass(5), "5"}, {new NonComparableTClass(19), "19"}, {new NonComparableTClass(1), "1"} }; var newTree = SerializeUtil.BinarySerializeDeserialize(splayTree); Assert.AreNotSame(splayTree, newTree); Assert.AreEqual(splayTree.Count, newTree.Count); var splayTreeEnumerator = splayTree.GetEnumerator(); var newTreeEnumerator = newTree.GetEnumerator(); while (splayTreeEnumerator.MoveNext()) { Assert.IsTrue(newTreeEnumerator.MoveNext()); Assert.AreEqual(splayTreeEnumerator.Current.Key.Number, newTreeEnumerator.Current.Key.Number); Assert.AreEqual(splayTreeEnumerator.Current.Value, newTreeEnumerator.Current.Value); //TODO: Need a way of accessing an item without splaying //Assert.AreEqual(newTree.ContainsKey(splayTreeEnumerator.Current.Key)); //Assert.AreEqual(newTree[treeEnumerator.Current.Key], splayTreeEnumerator.Current.Value); } Assert.IsFalse(newTreeEnumerator.MoveNext()); }
public void Simple() { var splayTree = new SplayTree<int, string>(); var dictionary = new Dictionary<int, string>(); var rand = new Random(Convert.ToInt32(DateTime.Now.Ticks % Int32.MaxValue)); for (var i = 0; i < 50; i++) { var gen = rand.Next(2000); while (dictionary.ContainsKey(gen)) { gen = rand.Next(2000); } dictionary.Add(gen, null); splayTree.Add(gen, gen.ToString()); Assert.IsTrue(splayTree.ContainsKey(gen)); Assert.AreEqual(splayTree[gen], gen.ToString()); } }
string _findNearest(SplayTree <float, string> candidates, float value) { if (candidates.ContainsKey(value)) { return(candidates[value]); } float lower = candidates.lastKeyBefore(value); float upper = candidates.firstKeyAfter(value); if (lower == null) { return(candidates[upper]); } if (upper == null) { return(candidates[lower]); } if (value > (lower + upper) / 2) { return(candidates[upper]); } else { return(candidates[lower]); } }
public TrackType(double length) { Length = length; Tracks = new List <Track>(); WaitingPlanes = new PairingHeap <Plane, double>(); WaitingPlanesForSearch = new SplayTree <Plane>(); }
public void SplayTree_Smoke_Test() { //insert test var tree = new SplayTree <int>(); tree.Insert(11); tree.Insert(6); tree.Insert(8); tree.Insert(19); tree.Insert(4); tree.Insert(10); tree.Insert(5); tree.Insert(17); tree.Insert(43); tree.Insert(49); tree.Insert(31); //delete tree.Delete(43); tree.Delete(11); tree.Delete(6); tree.Delete(8); tree.Delete(19); tree.Delete(4); tree.Delete(10); tree.Delete(5); tree.Delete(17); tree.Delete(49); tree.Delete(31); Assert.AreEqual(tree.Count, 0); tree.Insert(31); }
public void SplayTreeCopyToNotEnoughSpace() { var tree = new SplayTree <int, int> { { 1, 2 }, { 2, 3 } }; tree.CopyTo(new KeyValuePair <int, int> [1], 0); }
public void _Initialize() { _Tree = new SplayTree <string, string>(); foreach (var w in _Words) { _Tree.Add(w); } }
public void SplayTreeConstructorEmpty() { var tree = new SplayTree <string, bool>(); Assert.AreEqual(tree.Count, 0); Assert.IsFalse(tree.Root.HasValue); Assert.IsNotNull(tree.KeyComparer); }
public void CtorTest() { SplayTree t = new SplayTree(); Assert.IsNotNull(t, "A1"); Assert.IsNull(t.Left, "A2"); Assert.IsNull(t.Right, "A3"); }
public void CtorTest () { SplayTree t = new SplayTree (); Assert.IsNotNull (t, "A1"); Assert.IsNull (t.Left, "A2"); Assert.IsNull (t.Right, "A3"); }
public void Simple() { var splayTree = new SplayTree<int, string>(); Assert.IsFalse(splayTree.IsReadOnly); splayTree = GetTestTree(); Assert.IsFalse(splayTree.IsReadOnly); }
private static void lookupRand(SplayTree t, int max, long numOps) { Random r = new Random(); for (int i = 0; i < numOps; i++) { t.Lookup(r.Next(max)); } }
public void Simple() { var splayTree = new SplayTree <int, string>(); Assert.IsFalse(splayTree.IsReadOnly); splayTree = GetTestTree(); Assert.IsFalse(splayTree.IsReadOnly); }
private void ProcessDataHandler(Stack <int> commands) { var sw = Stopwatch.StartNew(); int offset = 0; // Prepare the tree var tree = new SplayTree <int, string>(); int insertCount = commands[offset++]; float insertDepthSum = 0; // Do insert commands for (; offset < insertCount + 1; offset++) { int key = commands[offset]; tree.Add(key, null); insertDepthSum += tree.LastSplayDepth / (float)(Math.Log10(tree.Count + 1) * 3.321928); // Normalized by the expected depth of a balanced binary tree; Plus one for when Count==1 } var findDepthSum = 0; int findCount = 0; offset--; // Do find commands while (++offset < commands.Count) { int key = commands[offset]; string val = tree[key]; findDepthSum += tree.LastSplayDepth; findCount++; } // Cleanup and store the measurements //tree.Clear(); // Disassembles tree node pointers .... not a good idea with a GC... sw.Stop(); float avgInsertDepth = insertDepthSum / insertCount; float avgFindDepth = findDepthSum / (float)findCount; lock (_results) _results.Add(insertCount, avgFindDepth); Interlocked.Increment(ref _currentJobsDone); Log("{0}/{1} done/waiting :: {2:F} sec :: {3}/{4} adds/finds : {5:F}/{6:F} insert depth factor/find depth", _currentJobsDone, Buffer.WaitingItemCount, sw.ElapsedMilliseconds * 0.001, insertCount, findCount, avgInsertDepth, avgFindDepth); }
/// <summary> ///A test for Clear ///</summary> public void ClearTestHelper <T>() { SplayTree <double> target = new SplayTree <double>(); target.Add(1); target.Add(2); target.Add(3); target.Clear(); Assert.IsNull(target.Root); }
public void Simple() { var splayTree = new SplayTree<int, string>(); Assert.IsTrue(splayTree.IsEmpty); splayTree = GetTestTree(); Assert.IsFalse(splayTree.IsEmpty); splayTree.Clear(); Assert.IsTrue(splayTree.IsEmpty); }
public void Simple() { var splayTree = new SplayTree<int, string>(); Assert.IsFalse(splayTree.ContainsKey(5)); splayTree.Add(4, "4"); Assert.AreEqual(splayTree[4], "4"); Assert.IsTrue(splayTree.ContainsKey(4)); Assert.IsFalse(splayTree.ContainsKey(5)); splayTree.Add(6, "6"); Assert.AreEqual(splayTree[6], "6"); Assert.IsTrue(splayTree.ContainsKey(4)); Assert.IsFalse(splayTree.ContainsKey(5)); Assert.IsTrue(splayTree.ContainsKey(6)); splayTree.Add(2, "2"); Assert.AreEqual(splayTree[2], "2"); Assert.IsTrue(splayTree.ContainsKey(2)); Assert.IsTrue(splayTree.ContainsKey(4)); Assert.IsFalse(splayTree.ContainsKey(5)); Assert.IsTrue(splayTree.ContainsKey(6)); splayTree.Add(5, "5"); Assert.AreEqual(splayTree[5], "5"); Assert.IsTrue(splayTree.ContainsKey(2)); Assert.IsTrue(splayTree.ContainsKey(4)); Assert.IsTrue(splayTree.ContainsKey(5)); Assert.IsTrue(splayTree.ContainsKey(6)); var rand = new Random(); splayTree = new SplayTree<int, string>(); var list = new List<int>(); for (var i = 0; i < 100; i++) { int r; do { r = rand.Next(5000); } while (list.Contains(r)); list.Add(r); splayTree.Add(r, null); Assert.IsTrue(splayTree.ContainsKey(r)); } }
public void Simple() { var splayTree = new SplayTree<int, string>(); Assert.AreEqual(splayTree.Count, 0); Assert.IsTrue(splayTree.Comparer is KeyValuePairComparer<int, string>); splayTree = new SplayTree<int, string>(new ReverseComparer<int>(Comparer<int>.Default)); Assert.AreEqual(splayTree.Count, 0); Assert.IsTrue(splayTree.Comparer.GetType().IsAssignableFrom(typeof(KeyValuePairComparer<int, string>))); }
public static SplayTree<int> InsertIntoTree(List<int> list) { var tree = new SplayTree<int>(); var comparisons = 0; foreach (var n in list) { comparisons += tree.Insert(n); } System.Console.Out.WriteLine("Splay Tree"); System.Console.Out.WriteLine("Insert"); System.Console.Out.WriteLine("Comparisons: {0}", comparisons); return tree; }
internal static SplayTree<int, string> GetTestTree() { var splayTree = new SplayTree<int, string> { {4, "4"}, {6, "6"}, {2, "2"}, {5, "5"}, {19, "19"}, {1, "1"} }; return splayTree; }
public void Simple() { var splayTree = new SplayTree<int, string>(); splayTree.Clear(); Assert.AreEqual(splayTree.Count, 0); splayTree = GetTestTree(); Assert.IsTrue(splayTree.ContainsKey(19)); splayTree.Clear(); Assert.AreEqual(splayTree.Count, 0); Assert.IsFalse(splayTree.ContainsKey(19)); }
public void KeyValuePair() { var splayTree = new SplayTree<int, string>(); Assert.IsFalse(splayTree.Contains(new KeyValuePair<int, string>(5, "5"))); splayTree.Add(4, "4"); Assert.IsTrue(splayTree.Contains(new KeyValuePair<int, string>(4, "4"))); Assert.IsFalse(splayTree.Contains(new KeyValuePair<int, string>(4, "5"))); splayTree.Add(6, "6"); Assert.IsTrue(splayTree.Contains(new KeyValuePair<int, string>(6, "6"))); Assert.IsFalse(splayTree.Contains(new KeyValuePair<int, string>(6, "5"))); }
public void Find() { SplayTree<int, string> tree = new SplayTree<int, string>(); var a = tree.Add(5, "a"); var b = tree.Add(3, "b"); var c = tree.Add(1, "c"); var d = tree.Add(2, "d"); var e = tree.Add(10, "e"); var found = tree.Find(5); Assert.IsTrue(found == a); Assert.IsTrue(tree.Root == a); }
public void TestInsert() { var t = new SplayTree<ulong>(); t.Insert(1); t.Insert(2); t.Insert(3); t.Insert(4); t.Insert(5); t.Insert(6); t.Insert(7); Assert.AreEqual("[6] [5] [7] [4] [3] [2] [1] ", t.ToString()); }
public void SearchTThreshold(IList<IList<int>> PostingLists, int T, out IList<int> docs, out IList<short> card) { // K - T = Number of mismatches (errors) int suggestedCardinality = 1024; docs = new List<int> (suggestedCardinality); card = new List<short> (suggestedCardinality); int docsI = 0; var Start = new int[PostingLists.Count]; Comparison<int> comptop = delegate(int x, int y) { this.CompCounter++; return PostingLists[x][Start[x]] - PostingLists[y][Start[y]]; }; SplayTree<int> pqueue = new SplayTree<int> (comptop); for (int i = 0; i < PostingLists.Count; i++) { pqueue.Add (i); } docs.Add (ShiftFirst (PostingLists, pqueue, Start)); card.Add (1); while (pqueue.Count > 0) { int docid = ShiftFirst (PostingLists, pqueue, Start); this.CompCounter++; if (docid == docs[docsI]) { card[docsI]++; } else { if (card[docsI] < T) { docs[docsI] = docid; card[docsI] = 1; } else { docs.Add (docid); card.Add (1); docsI++; } } } // The last item docs[docsI] can holds vals[docsI] < T // Console.WriteLine ("===> cards: "); if (card[docsI] < T) { card.RemoveAt (docsI); docs.RemoveAt (docsI); } }
public void Set() { var splayTree = new SplayTree<int, string>(); for (var i = 20; i > 10; i--) { splayTree.Add(i, i.ToString()); } for (var i = 0; i < 10; i++) { splayTree.Add(i, i.ToString()); } Assert.AreEqual(splayTree[0], "0"); splayTree[0] = "1"; Assert.AreEqual(splayTree[0], "1"); splayTree[1] = "4"; Assert.AreEqual(splayTree[1], "4"); }
public void Simple() { var splayTree = new SplayTree<string, int> { new KeyValuePair<string, int>("horse", 4), new KeyValuePair<string, int>("cat", 1), new KeyValuePair<string, int>("dog", 2), new KeyValuePair<string, int>("canary", 3) }; var visitor = new TrackingVisitor<KeyValuePair<string, int>>(); var inOrderVisitor = new InOrderVisitor<KeyValuePair<string, int>>(visitor); splayTree.DepthFirstTraversal(inOrderVisitor); Assert.AreEqual(visitor.TrackingList[0].Key, "canary"); Assert.AreEqual(visitor.TrackingList[1].Key, "cat"); Assert.AreEqual(visitor.TrackingList[2].Key, "dog"); Assert.AreEqual(visitor.TrackingList[3].Key, "horse"); }
public void Simple() { var splayTree = new SplayTree<int, string>(); for (var i = 20; i > 10; i--) { splayTree.Add(i, i.ToString()); } for (var i = 0; i <= 10; i++) { splayTree.Add(i, i.ToString()); } var values = splayTree.Values; for (var i = 0; i <= 20; i++) { Assert.IsTrue(values.Contains(i.ToString())); } Assert.AreEqual(values.Count, 21); }
public void TestChainFind() { var t = new SplayTree<ulong>(); t.Root = createNode(7); t.Root.Left = createNode(6); t.Root.Left.Left = createNode(5); t.Root.Left.Left.Left = createNode(4); t.Root.Left.Left.Left.Left = createNode(3); t.Root.Left.Left.Left.Left.Left = createNode(2); t.Root.Left.Left.Left.Left.Left.Left = createNode(1); t.Root.Left.Parent = t.Root; t.Root.Left.Left.Parent = t.Root.Left; t.Root.Left.Left.Left.Parent = t.Root.Left.Left; t.Root.Left.Left.Left.Left.Parent = t.Root.Left.Left.Left; t.Root.Left.Left.Left.Left.Left.Parent = t.Root.Left.Left.Left.Left; t.Root.Left.Left.Left.Left.Left.Left.Parent = t.Root.Left.Left.Left.Left.Left; Assert.AreEqual("[7] [6] [5] [4] [3] [2] [1] ", t.ToString()); t.Find(1); Assert.AreEqual("[1] [6] [4] [7] [2] [5] [3] ", t.ToString()); }
public void ExceptionNullVisitor() { var splayTree = new SplayTree<int, string>(); splayTree.AcceptVisitor(null); }
public void ExceptionEmpty() { var splayTree = new SplayTree<int, string>(); var i = splayTree.Maximum; }
int ShiftFirst(IList<IList<int>> PostingLists, SplayTree<int> pqueue, int[] Start) { int pIndex = pqueue.RemoveFirst (); var startIndex = Start[pIndex]; int docid = PostingLists[pIndex][startIndex]; startIndex++; if (startIndex < PostingLists[pIndex].Count) { Start[pIndex] = startIndex; pqueue.Add (pIndex); } return docid; }
public void Simple2() { var splayTree = new SplayTree<int, string>(); var dictionary = new Dictionary<int, string>(); var rand = new Random(Convert.ToInt32(DateTime.Now.Ticks % Int32.MaxValue)); for (var i = 0; i < 50; i++) { var gen = rand.Next(2000); while (dictionary.ContainsKey(gen)) { gen = rand.Next(2000); } dictionary.Add(gen, null); splayTree.Add(gen, gen.ToString()); Assert.AreEqual(splayTree.Count, i + 1); Assert.IsTrue(splayTree.ContainsKey(gen)); } using (var enumerator = dictionary.GetEnumerator()) { while (enumerator.MoveNext()) { Assert.IsTrue(splayTree.Remove(enumerator.Current)); } } }
public void Simple1() { var splayTree = new SplayTree<int, string> { {4, "4"}, {6, "6"}, {2, "2"}, {5, "5"}, {19, "19"}, {1, "1"} }; Assert.AreEqual(splayTree.Count, 6); Assert.IsTrue(splayTree.ContainsKey(4)); Assert.IsTrue(splayTree.ContainsKey(6)); Assert.IsTrue(splayTree.ContainsKey(2)); Assert.IsTrue(splayTree.ContainsKey(5)); Assert.IsTrue(splayTree.ContainsKey(19)); Assert.IsTrue(splayTree.ContainsKey(1)); Assert.IsFalse(splayTree.Remove(20)); Assert.IsTrue(splayTree.Remove(4)); Assert.AreEqual(splayTree.Count, 5); Assert.IsFalse(splayTree.ContainsKey(4)); Assert.IsTrue(splayTree.ContainsKey(6)); Assert.IsTrue(splayTree.ContainsKey(2)); Assert.IsTrue(splayTree.ContainsKey(5)); Assert.IsTrue(splayTree.ContainsKey(19)); Assert.IsTrue(splayTree.ContainsKey(1)); Assert.IsTrue(splayTree.Remove(2)); Assert.AreEqual(splayTree.Count, 4); Assert.IsFalse(splayTree.ContainsKey(4)); Assert.IsTrue(splayTree.ContainsKey(6)); Assert.IsFalse(splayTree.ContainsKey(2)); Assert.IsTrue(splayTree.ContainsKey(5)); Assert.IsTrue(splayTree.ContainsKey(19)); Assert.IsTrue(splayTree.ContainsKey(1)); Assert.IsTrue(splayTree.Remove(19)); Assert.AreEqual(splayTree.Count, 3); Assert.IsFalse(splayTree.ContainsKey(4)); Assert.IsTrue(splayTree.ContainsKey(6)); Assert.IsFalse(splayTree.ContainsKey(2)); Assert.IsTrue(splayTree.ContainsKey(5)); Assert.IsFalse(splayTree.ContainsKey(19)); Assert.IsTrue(splayTree.ContainsKey(1)); Assert.IsFalse(splayTree.Remove(20)); Assert.IsTrue(splayTree.Remove(1)); Assert.AreEqual(splayTree.Count, 2); Assert.IsFalse(splayTree.ContainsKey(4)); Assert.IsTrue(splayTree.ContainsKey(6)); Assert.IsFalse(splayTree.ContainsKey(2)); Assert.IsTrue(splayTree.ContainsKey(5)); Assert.IsFalse(splayTree.ContainsKey(19)); Assert.IsFalse(splayTree.ContainsKey(1)); Assert.IsTrue(splayTree.Remove(6)); Assert.AreEqual(splayTree.Count, 1); Assert.IsFalse(splayTree.ContainsKey(4)); Assert.IsFalse(splayTree.ContainsKey(6)); Assert.IsFalse(splayTree.ContainsKey(2)); Assert.IsTrue(splayTree.ContainsKey(5)); Assert.IsFalse(splayTree.ContainsKey(19)); Assert.IsFalse(splayTree.ContainsKey(1)); Assert.IsTrue(splayTree.Remove(5)); Assert.AreEqual(splayTree.Count, 0); Assert.IsFalse(splayTree.ContainsKey(4)); Assert.IsFalse(splayTree.ContainsKey(6)); Assert.IsFalse(splayTree.ContainsKey(2)); Assert.IsFalse(splayTree.ContainsKey(5)); Assert.IsFalse(splayTree.ContainsKey(19)); Assert.IsFalse(splayTree.ContainsKey(1)); Assert.IsFalse(splayTree.Remove(1)); }
public void ExceptionDuplicate() { var splayTree = new SplayTree<int, string> { { 4, "4" }, { 4, "4" } }; }
bool PqueueHasNext(SplayTree<int> pqueue, int next, int[] pos, IList<IList<int>> invindex) { return invindex[next][pos[next]] + 1 == pqueue.GetFirstWithSplay (); }
public void ExceptionInvalidIndexerGet() { var splayTree = new SplayTree<int, string>(); var s = splayTree[4]; }
public void ExceptionInvalidIndexerSet() { var splayTree = new SplayTree<int, string>(); splayTree[4] = "testString"; }