////////////////////////////////////////////////////////////////////////////
public Node Merge(Node aNode)
{
if (aNode is StdNode)
{
StdNode node = (StdNode)aNode;
Node newLeft = node.left != null?Merge(node.left) : this;
return(new StdNode(node.elt, node.hashcode, newLeft, node.right));
}
else
{
ArraysNode node = (ArraysNode)aNode;
if (count > node.count) // count > node.count >= 2 => count >= 3
{
Node left = NewNode(elts, hashcodes, first, count - 1);
int idx = first + count - 1;
return(new StdNode(elts[idx], hashcodes[idx], left, node));
}
else // node.count >= count >= 2 => count >= 2
{
Node right = NewNode(node.elts, node.hashcodes, node.first + 1, node.count - 1);
return(new StdNode(node.elts[node.first], node.hashcodes[node.first], this, right));
}
}
}
public void TestDeleteComplex()
{
var testData = TestDataGenerator.GetKeysAndValues(treeCount);
var treeHead = new StdNode <int, string>();
List <int> existingKeys = new List <int>(testData.Item1);
List <int> deletedKeys = new List <int>();
Random rnd = new Random();
for (int i = 0; i < treeCount; i++)
{
treeHead.Insert(testData.Item1[i], testData.Item2[i]);
}
while (existingKeys.Count > 0)
{
foreach (int key in existingKeys)
{
Assert.AreEqual(Convert.ToString(key), treeHead.Find(key));
}
int keyToDelete = existingKeys[rnd.Next(0, existingKeys.Count - 1)];
treeHead.Delete(keyToDelete);
deletedKeys.Add(keyToDelete);
existingKeys.RemoveAll(x => x == keyToDelete);
int deletedKeyToFind = deletedKeys[rnd.Next(0, deletedKeys.Count - 1)];
Assert.AreEqual(null, treeHead.Find(deletedKeyToFind));
}
}
public void TestCreateTree()
{
//var treeHead = MockFabric.GetMockForBSTree(TestDataGenerator.GetKeysAndValues(treeCount)).Object;
var treeHead = new StdNode<int, string>();
for (int i = 0; i < treeCount; i++)
treeHead.Insert(i, Convert.ToString(i));
}
////////////////////////////////////////////////////////////////////////////
public StdNode Insert(Obj elt, uint hashcode)
{
Node right = null, left = null;
int lastIdx = first + count - 1;
int idx = EltIdx(elt, hashcode);
if (idx >= 0)
{
// <elt> was found
int leftCount = idx - first;
if (leftCount > 1)
{
left = NewNode(elts, hashcodes, first, leftCount);
}
else if (leftCount == 1)
{
left = new StdNode(elts[first], hashcodes[first]);
}
int rightCount = lastIdx - idx;
if (rightCount > 1)
{
right = NewNode(elts, hashcodes, idx + 1, rightCount);
}
else if (rightCount == 1)
{
right = new StdNode(elts[lastIdx], hashcodes[lastIdx]);
}
}
else
{
// <elt> was not found
int insIdx = -idx - 1;
int leftCount = insIdx - first;
if (leftCount > 1)
{
left = NewNode(elts, hashcodes, first, leftCount);
}
else if (leftCount == 1)
{
left = new StdNode(elts[first], hashcodes[first]);
}
int rightCount = lastIdx - insIdx + 1;
if (rightCount > 1)
{
right = NewNode(elts, hashcodes, insIdx, rightCount);
}
else if (rightCount == 1)
{
right = new StdNode(elts[insIdx], hashcodes[insIdx]);
}
}
return(new StdNode(elt, hashcode, left, right));
}
protected StdNode <int, string> GetTree(int count)
{
var treeHead = new StdNode <int, string>();
var testData = TestDataGenerator.GetKeysAndValues(count);
FillTreeByTestData(treeHead, testData);
return(treeHead);
}
protected void FillTreeByTestData(StdNode <int, string> head, Tuple <int[], string[]> data)
{
var keys = data.Item1;
var values = data.Item2;
for (int i = 0; i < keys.Length; i++)
{
head.Insert(keys[i], values[i]);
}
}
public void TestCreateTree()
{
//var treeHead = MockFabric.GetMockForBSTree(TestDataGenerator.GetKeysAndValues(treeCount)).Object;
var treeHead = new StdNode <int, string>();
for (int i = 0; i < treeCount; i++)
{
treeHead.Insert(i, Convert.ToString(i));
}
}
internal StdNode(Obj key, Obj value, uint hashcode, Node left, Node right)
{
this.key = key;
this.value = value;
this.hashcode = hashcode;
this.size = 1 + (left != null ? left.Size() : 0) + (right != null ? right.Size() : 0);
this.left = left;
this.right = right;
if (left != null)
{
if (left is StdNode)
{
StdNode node = (StdNode)left;
Debug.Assert(
node.hashcode < hashcode || (node.hashcode == hashcode && node.key.QuickOrder(key) < 0)
);
}
else
{
ArraysNode node = (ArraysNode)left;
int last = node.first + node.count - 1;
Debug.Assert(
node.hashcodes[last] < hashcode ||
(node.hashcodes[last] == hashcode && node.keys[last].QuickOrder(key) < 0)
);
}
}
if (right != null)
{
if (right is StdNode)
{
StdNode node = (StdNode)right;
Debug.Assert(
hashcode < node.hashcode || (node.hashcode == hashcode && key.QuickOrder(node.key) < 0)
);
}
else
{
ArraysNode node = (ArraysNode)right;
int first = node.first;
Debug.Assert(
hashcode < node.hashcodes[first] ||
(node.hashcodes[first] == hashcode && key.QuickOrder(node.keys[first]) < 0)
);
}
}
}
public void TestInsertAndFind()
{
var testData = TestDataGenerator.GetKeysAndValues(treeCount);
//var treeHead = MockFabric.GetMockForBSTree(testData).Object;
var treeHead = new StdNode <int, string>();
for (int i = 0; i < treeCount; i++)
{
treeHead.Insert(testData.Item1[i], testData.Item2[i]);
}
for (int i = 0; i < treeCount; i++)
{
Assert.AreEqual(testData.Item2[i], treeHead.Find(testData.Item1[i]));
}
}
public void TestDelete3()
{
var treeHead = new StdNode<int, string>();
var keys = new List<int>(new int[] { 10, 5, 15, 12, 17, 18 });
var keyToDelete = keys[2];
foreach (int key in keys)
treeHead.Insert(key, Convert.ToString(key));
treeHead.Delete(keyToDelete);
keys.Remove(keyToDelete);
Assert.AreEqual(null, treeHead.Find(keyToDelete));
foreach (int key in keys)
Assert.AreEqual(Convert.ToString(key), treeHead.Find(key));
}
public void TestDelete3()//удаление узла с обоими потомками, но у правого потомка нет левой ветви
{
var treeHead = new StdNode <int, string>();
var keys = new List <int>(new int[] { 10, 5, 15, 12, 17, 18 });
var keyToDelete = keys[2];
foreach (int key in keys)
{
treeHead.Insert(key, Convert.ToString(key));
}
treeHead.Delete(keyToDelete);
keys.Remove(keyToDelete);
Assert.AreEqual(null, treeHead.Find(keyToDelete));
foreach (int key in keys)
{
Assert.AreEqual(Convert.ToString(key), treeHead.Find(key));
}
}
public void TestDelete2()//удаление узла с одним из потомков
{
var treeHead = new StdNode <int, string>();
var keys = new List <int>(new int[] { 10, 5, 15, 12 });
var keyToDelete = keys[2];
foreach (int key in keys)
{
treeHead.Insert(key, Convert.ToString(key));
}
treeHead.Delete(keyToDelete);
keys.Remove(keyToDelete);
Assert.AreEqual(null, treeHead.Find(keyToDelete));
foreach (int key in keys)
{
Assert.AreEqual(Convert.ToString(key), treeHead.Find(key));
}
}
public void TestInsertAndFind()
{
var testData = TestDataGenerator.GetKeysAndValues(treeCount);
//var treeHead = MockFabric.GetMockForBSTree(testData).Object;
var treeHead = new StdNode<int, string>();
for (int i = 0; i < treeCount; i++)
treeHead.Insert(testData.Item1[i], testData.Item2[i]);
for (int i = 0; i < treeCount; i++)
Assert.AreEqual(testData.Item2[i], treeHead.Find(testData.Item1[i]));
}
public void TestDeleteComplex()
{
var testData = TestDataGenerator.GetKeysAndValues(treeCount);
var treeHead = new StdNode<int, string>();
List<int> existingKeys = new List<int>(testData.Item1);
List<int> deletedKeys = new List<int>();
Random rnd = new Random();
for (int i = 0; i < treeCount; i++)
treeHead.Insert(testData.Item1[i], testData.Item2[i]);
while (existingKeys.Count > 0)
{
foreach (int key in existingKeys)
Assert.AreEqual(Convert.ToString(key), treeHead.Find(key));
int keyToDelete = existingKeys[rnd.Next(0, existingKeys.Count - 1)];
treeHead.Delete(keyToDelete);
deletedKeys.Add(keyToDelete);
existingKeys.RemoveAll(x => x == keyToDelete);
int deletedKeyToFind = deletedKeys[rnd.Next(0, deletedKeys.Count - 1)];
Assert.AreEqual(null, treeHead.Find(deletedKeyToFind));
}
}
