public void Add(T item)
{
if (!Contains(item))
{
data.Insert(item);
}
else
{
throw new ArgumentException($"Item {item} already in set");
}
}
public void ZigZagTest()
{
SplayTree <int> tree = new SplayTree <int>();
tree.Insert(10);
tree.Insert(15);
tree.Insert(13);
Assert.AreEqual(3, tree.Count);
Assert.AreEqual(13, tree.Root.Value);
Assert.AreEqual(15, tree.Root.Right.Value);
Assert.AreEqual(10, tree.Root.Left.Value);
}
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));
}
}
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 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 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());
}
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 NotFailOnStackOverflow()
{
var tree = new SplayTree <int>();
foreach (var e in Enumerable.Range(0, 10000))
{
tree.Insert(e);
tree.Search(e);
}
}
public static void SplayTreeTest()
{
SplayTree tree = new SplayTree();
for (int i = 7; i > 0; i--)
{
tree.Insert(i);
}
tree.Find(1);
tree.Find(3);
}
public void InsertDuplicateTest()
{
var st = new SplayTree();
for (int i = 1; i < 100; i++)
{
st.Insert(1);
}
Assert.AreEqual("1", st.ToString());
}
public void TestRemoveOne()
{
var arr = new int[] { 30, 70, 15, 50, 5, 60, 85, 10, 20, 35, 40, 55, 65, 80, 90 };
var tree = new SplayTree <int>();
foreach (var e in arr)
{
tree.Insert(e);
}
tree.Remove(15);
Assert.AreEqual(null, tree.Search(15));
}
public void SplayTree_Accuracy_Test()
{
var nodeCount = 1000;
var rnd = new Random();
var sorted = Enumerable.Range(1, nodeCount).ToList();
var randomNumbers = sorted
.OrderBy(x => rnd.Next())
.ToList();
var tree = new SplayTree <int>();
for (int i = 0; i < nodeCount; i++)
{
tree.Insert(randomNumbers[i]);
tree.Root.VerifyCount();
Assert.IsTrue(tree.Count == i + 1);
}
for (int i = 0; i < sorted.Count; i++)
{
Assert.AreEqual(sorted[i], tree.ElementAt(i));
Assert.AreEqual(i, tree.IndexOf(sorted[i]));
}
//shuffle again before deletion tests
randomNumbers = Enumerable.Range(1, nodeCount)
.OrderBy(x => rnd.Next())
.ToList();
//IEnumerable test using linq
Assert.AreEqual(tree.Count, tree.Count());
Assert.AreEqual(tree.Count, tree.AsEnumerableDesc().Count());
for (int i = 0; i < nodeCount; i++)
{
if (rnd.NextDouble() >= 0.5)
{
tree.Delete(randomNumbers[i]);
}
else
{
var index = tree.IndexOf(randomNumbers[i]);
Assert.AreEqual(tree.ElementAt(index), randomNumbers[i]);
tree.RemoveAt(index);
}
tree.Root.VerifyCount();
Assert.IsTrue(tree.Count == nodeCount - 1 - i);
}
Assert.IsTrue(tree.Count == 0);
}
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;
}
public void AllOpsTest()
{
SplayTree <int> tree = new SplayTree <int>();
tree.Insert(10);
Assert.AreEqual(10, tree.Root.Value);
tree.Insert(15);
Assert.AreEqual(15, tree.Root.Value);
tree.Insert(13);
Assert.AreEqual(13, tree.Root.Value);
Assert.AreEqual(10, tree.Root.Left.Value);
Assert.AreEqual(15, tree.Root.Right.Value);
tree.Insert(16);
Assert.AreEqual(16, tree.Root.Value);
Assert.AreEqual(15, tree.Root.Left.Value);
Assert.AreEqual(13, tree.Root.Left.Left.Value);
Assert.AreEqual(10, tree.Root.Left.Left.Left.Value);
tree.Insert(18);
Assert.AreEqual(18, tree.Root.Value);
Assert.AreEqual(16, tree.Root.Left.Value);
Assert.AreEqual(15, tree.Root.Left.Left.Value);
Assert.AreEqual(13, tree.Root.Left.Left.Left.Value);
Assert.AreEqual(10, tree.Root.Left.Left.Left.Left.Value);
tree.Insert(17);
Assert.AreEqual(17, tree.Root.Value);
Assert.AreEqual(18, tree.Root.Right.Value);
Assert.AreEqual(16, tree.Root.Left.Value);
Assert.AreEqual(15, tree.Root.Left.Left.Value);
Assert.AreEqual(13, tree.Root.Left.Left.Left.Value);
Assert.AreEqual(10, tree.Root.Left.Left.Left.Left.Value);
tree.Insert(14);
Assert.AreEqual(14, tree.Root.Value);
Assert.AreEqual(13, tree.Root.Left.Value);
Assert.AreEqual(10, tree.Root.Left.Left.Value);
Assert.AreEqual(16, tree.Root.Right.Value);
Assert.AreEqual(15, tree.Root.Right.Left.Value);
Assert.AreEqual(17, tree.Root.Right.Right.Value);
Assert.AreEqual(18, tree.Root.Right.Right.Right.Value);
tree.Insert(12);
Assert.AreEqual(12, tree.Root.Value);
Assert.AreEqual(10, tree.Root.Left.Value);
Assert.AreEqual(14, tree.Root.Right.Value);
Assert.AreEqual(13, tree.Root.Right.Left.Value);
Assert.AreEqual(16, tree.Root.Right.Right.Value);
Assert.AreEqual(15, tree.Root.Right.Right.Left.Value);
Assert.AreEqual(17, tree.Root.Right.Right.Right.Value);
Assert.AreEqual(18, tree.Root.Right.Right.Right.Right.Value);
Assert.AreEqual(8, tree.Count);
}
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 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 ZigTest()
{
SplayTree <int> tree = new SplayTree <int>();
for (int i = 9; i >= 0; --i)
{
tree.Insert(i);
}
var head = tree.Root;
Assert.AreEqual(10, tree.Count);
for (int i = 0; i <= 9; ++i)
{
Assert.AreEqual(i, head.Value);
head = head.Right;
}
}
public void PreoderTest()
{
var tree = new SplayTree <int>();
int[] array = { 10, 15, 20, 30, 40, 50, 25, 27, 14, 13, 35, 45 };
int[] preorder = { 45, 35, 13, 10, 27, 14, 20, 15, 25, 30, 40, 50 };
foreach (var item in array)
{
tree.Insert(item);
}
Assert.AreEqual(array.Length, tree.Count);
int i = 0;
foreach (var item in tree.GetPreorderTraversal())
{
Assert.AreEqual(preorder[i++], item);
}
}
public void Splay_ZigZig()
{
var arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var tree = new SplayTree <int>();
foreach (var e in arr)
{
tree.Insert(e);
}
tree.Splay(tree.root.Left.Left);
Assert.AreEqual(8, tree.root.Value);
Assert.AreEqual(7, tree.root.Left.Value);
Assert.AreEqual(6, tree.root.Left.Left.Value);
Assert.AreEqual(5, tree.root.Left.Left.Left.Value);
Assert.AreEqual(4, tree.root.Left.Left.Left.Left.Value);
Assert.AreEqual(3, tree.root.Left.Left.Left.Left.Left.Value);
Assert.AreEqual(2, tree.root.Left.Left.Left.Left.Left.Left.Value);
Assert.AreEqual(1, tree.root.Left.Left.Left.Left.Left.Left.Left.Value);
Assert.AreEqual(9, tree.root.Right.Value);
Assert.AreEqual(10, tree.root.Right.Right.Value);
var arr2 = new int[] { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
var tree2 = new SplayTree <int>();
foreach (var e in arr2)
{
tree2.Insert(e);
}
tree2.Splay(tree2.root.Right.Right);
Assert.AreEqual(3, tree2.root.Value);
Assert.AreEqual(4, tree2.root.Right.Value);
Assert.AreEqual(5, tree2.root.Right.Right.Value);
Assert.AreEqual(6, tree2.root.Right.Right.Right.Value);
Assert.AreEqual(7, tree2.root.Right.Right.Right.Right.Value);
Assert.AreEqual(8, tree2.root.Right.Right.Right.Right.Right.Value);
Assert.AreEqual(9, tree2.root.Right.Right.Right.Right.Right.Right.Value);
Assert.AreEqual(10, tree2.root.Right.Right.Right.Right.Right.Right.Right.Value);
Assert.AreEqual(2, tree2.root.Left.Value);
Assert.AreEqual(1, tree2.root.Left.Left.Value);
}
public void ContainsAndFindTest()
{
var tree = new SplayTree <int>();
int N = 200;
for (int i = 0; i < N; ++i)
{
tree.Insert(i + 10);
}
Assert.AreEqual(N, tree.Count);
for (int i = N - 1; i >= 0; --i)
{
Assert.AreEqual(10 + i, tree.Find(i + 10).Value);
}
for (int i = 0; i < N * N; ++i)
{
tree.Find(N - 1);
}
Assert.AreEqual(N - 1, tree.Root.Value);
}
public void TestInsertAndSearch()
{
var arr = new int[] { 30, 70, 15, 50, 5, 60, 85, 10, 20, 35, 40, 55, 65, 80, 90 };
var tree = new SplayTree <int>();
foreach (var e in arr)
{
tree.Insert(e);
}
var tr = true;
foreach (var item in arr)
{
if (tree.Search(item) == null)
{
tr = false;
}
}
Assert.AreEqual(tr, true);
}
public void MergeTrees()
{
var arr1 = new int[] { 10, 15, 7, 5, 29, 6, 14, 26, 4, 1, 8, 21, 23, 19, 20, 13, 11 };
var tree1 = new SplayTree <int>();
foreach (var e in arr1)
{
tree1.Insert(e);
}
var arr2 = new int[] { 30, 70, 45, 50, 56, 60, 85, 101, 201, 35, 40, 55, 65, 80, 90 };
var tree2 = new SplayTree <int>();
foreach (var e in arr2)
{
tree2.Insert(e);
}
tree1.Merge(tree1, tree2);
var tr = true;
foreach (var item in arr1)
{
if (tree1.Search(item) == null)
{
tr = false;
}
}
Assert.AreEqual(tr, true);
;
foreach (var item in arr2)
{
if (tree1.Search(item) == null)
{
tr = false;
}
}
Assert.AreEqual(tr, true);
}
public void SplayForRoot()
{
var arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var tree = new SplayTree <int>();
foreach (var e in arr)
{
tree.Insert(e);
}
tree.Splay(tree.root);
Assert.AreEqual(10, tree.root.Value);
Assert.AreEqual(9, tree.root.Left.Value);
Assert.AreEqual(8, tree.root.Left.Left.Value);
Assert.AreEqual(7, tree.root.Left.Left.Left.Value);
Assert.AreEqual(6, tree.root.Left.Left.Left.Left.Value);
Assert.AreEqual(5, tree.root.Left.Left.Left.Left.Left.Value);
Assert.AreEqual(4, tree.root.Left.Left.Left.Left.Left.Left.Value);
Assert.AreEqual(3, tree.root.Left.Left.Left.Left.Left.Left.Left.Value);
Assert.AreEqual(2, tree.root.Left.Left.Left.Left.Left.Left.Left.Left.Value);
Assert.AreEqual(1, tree.root.Left.Left.Left.Left.Left.Left.Left.Left.Left.Value);
}
public void TestSplit()
{
var arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var tree = new SplayTree <int>();
foreach (var e in arr)
{
tree.Insert(e);
}
Tuple <SplayNode <int>, SplayNode <int> > tuple = tree.Split(5);
Assert.AreEqual(4, tuple.Item1.Value);
Assert.AreEqual(3, tuple.Item1.Left.Value);
Assert.AreEqual(2, tuple.Item1.Left.Left.Value);
Assert.AreEqual(1, tuple.Item1.Left.Left.Left.Value);
Assert.AreEqual(5, tuple.Item2.Value);
Assert.AreEqual(10, tuple.Item2.Right.Value);
Assert.AreEqual(8, tuple.Item2.Right.Left.Value);
Assert.AreEqual(6, tuple.Item2.Right.Left.Left.Value);
Assert.AreEqual(9, tuple.Item2.Right.Left.Right.Value);
Assert.AreEqual(7, tuple.Item2.Right.Left.Left.Right.Value);
}
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 GlobalTest()
{
SplayTree tree = new SplayTree(100);
tree.Insert(50);
Assert.AreEqual(50, tree.root.value);
tree.Insert(101);
Assert.AreEqual(101, tree.root.value);
tree.Insert(0);
Assert.AreEqual(0, tree.root.value);
tree.Insert(1);
Assert.AreEqual(1, tree.root.value);
tree.Insert(-100);
Assert.AreEqual(-100, tree.root.value);
tree.Insert(90);
Assert.AreEqual(90, tree.root.value);
tree.Insert(70);
Assert.AreEqual(70, tree.root.value);
tree.Insert(1000);
Assert.AreEqual(1000, tree.root.value);
tree.Insert(1010);
Assert.AreEqual(1010, tree.root.value);
tree.Insert(-9000);
Assert.AreEqual(-9000, tree.root.value);
tree.Insert(65);
Assert.AreEqual(65, tree.root.value);
tree.Insert(9999);
Assert.AreEqual(9999, tree.root.value);
tree.Insert(346);
Assert.AreEqual(346, tree.root.value);
tree.Insert(23412);
Assert.AreEqual(23412, tree.root.value);
tree.Insert(-558);
Assert.AreEqual(-558, tree.root.value);
tree.Insert(63453);
Assert.AreEqual(63453, tree.root.value);
}
