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";
}
