/**
* Verejná metóda delete slúži na zmazanie prvku na základe poskytnutých sekundárnych kľúčov a primárneho
* kľúča, ktorý slúži na presnú identifikáciu prvku.
*
* @param keys
* sekundárne kľúče, podľa ktorých sa vyhľadajú všetky KDTNode, ktoré majú rovnaký kľúč.
*
* @param primaryKey
* primárny kľúč, ktorý umožňuje presne identifikovať prvok, ktorý má byť zo zoznamu odstránený.
*
* @return vráti dáta vrcholu, ktorý bol odstránený. V prípade ak nebol nájdený žiaden vrchol alebo
* sa zadaný primárny kľúč nezhodoval s primárnym kľúčom žiadneho z najdených prvkov je
* vrátená hodnota null.
*/
public T Delete(K[] keys, P primaryKey)
{
LinkedList <KDTreeNode <K, T, P> > result = this.Search(keys);
if (result.Count == 0)
{
return(default(T));
}
KDTreeNode <K, T, P> deleted = null;
foreach (KDTreeNode <K, T, P> node in result)
{
if (node.PrimaryKey.Equals(primaryKey))
{
deleted = node;
break;
}
}
if (deleted == null)
{
return(default(T));
}
T data = deleted.Data;
this.Delete(deleted);
return(data);
}
/**
* Metóda na vkladanie dát to štruktúry.
*
* @param keys
* pole kľúčov, na základe ktorých sú dáta v strome vložené na správne miesto.
*
* @param element
* dáta, ktoré majú byť v strome uložené.
*
* @return vráti null ak sa veľkosť poľa poskytnutých kľúčov líši od hodnnoty atribútu
* numberOfKeys. Ak je táto podmienka splnená, metóda vracia KDTreeNode, s
* novo vloženými dátami.
*/
public bool Insert(K[] keys, T element, P primaryKey)
{
if (keys.Length != this._numberOfKeys)
{
return(false);
}
if (this.Root == null)
{
this.Root = new KDTreeNode <K, T, P>(keys, element, primaryKey, 0);
++Count;
return(true);
}
int level = 0;
KDTreeNode <K, T, P> node;
KDTreeNode <K, T, P> parent = this.Root;
int dimension = 0;
while (true)
{
dimension = level++ % _numberOfKeys;
if (keys[dimension].CompareTo(parent.Keys[dimension]) <= 0)
{
if (parent.LeftSon == null)
{
node = new KDTreeNode <K, T, P>(keys, element, primaryKey, level);
node.Parent = parent;
parent.LeftSon = node;
++Count;
return(true);
}
else
{
parent = parent.LeftSon;
}
}
else
{
if (parent.RightSon == null)
{
node = new KDTreeNode <K, T, P>(keys, element, primaryKey, level);
node.Parent = parent;
parent.RightSon = node;
++Count;
return(true);
}
else
{
parent = parent.RightSon;
}
}
}
}
public KDTInOrderIterator(KDTree <K, T, P> tree)
{
next = tree.Root;
if (next == null)
{
return;
}
while (next.LeftSon != null)
{
next = next.LeftSon;
}
}
/**
* Ide o metódu, ktorá v LinkedListe vráti KDTreeNode stromu v poradí post-order.
*
* @return linked-list vrcholov podľa zoradenia post-order.
*/
protected LinkedList <KDTreeNode <K, T, P> > PostOreder()
{
LinkedList <KDTreeNode <K, T, P> > result = new LinkedList <KDTreeNode <K, T, P> >();
if (this.Root == null)
{
return(result);
}
Stack <KDTreeNode <K, T, P> > stack = new Stack <KDTreeNode <K, T, P> >();
KDTreeNode <K, T, P> currentNode;
KDTreeNode <K, T, P> previousNode = null;
stack.Push(this.Root);
while (stack.Count != 0)
{
currentNode = stack.Peek();
if (previousNode == null || currentNode == previousNode.LeftSon || currentNode == previousNode.RightSon)
{
if (currentNode.LeftSon != null)
{
stack.Push(currentNode.LeftSon);
}
else if (currentNode.RightSon != null)
{
stack.Push(currentNode.RightSon);
}
}
else if (previousNode == currentNode.LeftSon)
{
if (currentNode.RightSon != null)
{
stack.Push(currentNode.RightSon);
}
}
else
{
stack.Pop();
result.AddLast(currentNode);
}
previousNode = currentNode;
}
return(result);
}
/**
* Ide o metódu, ktorá v LinkedListe vráti KDTreeNode stromu v poradí in-order.
*
* @return linked-list vrcholov podľa zoradenia in-order.
*/
protected LinkedList <KDTreeNode <K, T, P> > InOrder()
{
LinkedList <KDTreeNode <K, T, P> > result = new LinkedList <KDTreeNode <K, T, P> >();
if (this.Root == null)
{
return(result);
}
Stack <KDTreeNode <K, T, P> > stack = new Stack <KDTreeNode <K, T, P> >();
KDTreeNode <K, T, P> currentNode = this.Root;
bool hotovo = false;
while (!hotovo)
{
if (currentNode != null)
{
stack.Push(currentNode);
currentNode = currentNode.LeftSon;
}
else
{
if (stack.Count == 0)
{
hotovo = true;
}
else
{
currentNode = stack.Pop();
result.AddLast(currentNode);
currentNode = currentNode.RightSon;
}
}
}
return(result);
}
public void Reset()
{
next = null;
}
/**
* Tato metóda sa v štruktúre nepoužíva. Umožňuje nájsť minimálnu hodnotu v podstrome poskytnutého vrcholu.
*
* @param startingNode
* odkaz na vrchol, v ktorého podstromoch je hľadaná minimalna hodnota kľúča v závislosti od dimenzie.
*
* @param left
* parameter slúži na identifikáciu toho, v ktorom podstrome sa má minimum hľadať.
*
* @return
*/
protected LinkedList <KDTreeNode <K, T, P> > FindMinimal(KDTreeNode <K, T, P> startingNode, bool left)
{
int actualLevel = startingNode.getLevel();
int wantedDimension = actualLevel % _numberOfKeys;
Queue <KDTreeNode <K, T, P> > queueOfNodes = new Queue <KDTreeNode <K, T, P> >();
LinkedList <KDTreeNode <K, T, P> > result = new LinkedList <KDTreeNode <K, T, P> >();
KDTreeNode <K, T, P> currentNode = null;
if (left)
{
currentNode = startingNode.LeftSon;
}
else
{
currentNode = startingNode.RightSon;
}
if (currentNode == null)
{
return(result);
}
K minimalFound = currentNode.Keys[wantedDimension];
KDTreeNode <K, T, P> tmpNode;
queueOfNodes.Enqueue(currentNode);
while (queueOfNodes.Count != 0)
{
currentNode = queueOfNodes.Dequeue();
actualLevel = currentNode.getLevel();
if (currentNode.Keys[wantedDimension].CompareTo(minimalFound) < 0)
{
minimalFound = currentNode.Keys[wantedDimension];
result.Clear();
result.AddLast(currentNode);
}
else if (currentNode.Keys[wantedDimension].CompareTo(minimalFound) == 0)
{
result.AddLast(currentNode);
}
if (wantedDimension == actualLevel % _numberOfKeys)
{
tmpNode = currentNode.LeftSon;
if (tmpNode != null)
{
queueOfNodes.Enqueue(tmpNode);
}
}
else
{
tmpNode = currentNode.LeftSon;
}
if (tmpNode != null)
{
queueOfNodes.Enqueue(tmpNode);
}
tmpNode = currentNode.RightSon;
if (tmpNode != null)
{
queueOfNodes.Enqueue(tmpNode);
}
}
return(result);
}
/**
* Metóda na intervalové vyhľadávanie. Vráti linked list obsahujúci vrcholy, ktoré sa nachádzali
* v danom rozsahu.
*
* @param lowerBound
* množina hodnôt, ktoré predstavujú spodnú hranicu pre jednotlivé kľúče v závislosti od dimenzie.
*
* @param upperBound
* množina hodnôt, ktoré predstavujú hornú hranicu pre jednotlivé kľúče v závislosti od dimenzie.
*
* @return linked-list obsahujúci prvky nachádzajúce sa v zadanom rozsahu. V prípade ak bol
* zadaný nesprávny počet kľúčov je vrátená hodnota null.
*/
private LinkedList <KDTreeNode <K, T, P> > rangeSearch(K[] lowerBound, K[] upperBound)
{
if (this._numberOfKeys != lowerBound.Length || this._numberOfKeys != upperBound.Length)
{
return(null);
}
LinkedList <KDTreeNode <K, T, P> > result = new LinkedList <KDTreeNode <K, T, P> >();
if (this.Root == null)
{
return(result);
}
int depth = 0;
int dimension = depth % this._numberOfKeys;
bool layInRange = false;
Queue <KDTreeNode <K, T, P> > queueOfNodes = new Queue <KDTreeNode <K, T, P> >();
queueOfNodes.Enqueue(this.Root);
KDTreeNode <K, T, P> currentNode = null;
KDTreeNode <K, T, P> tmpNode = null;
while (queueOfNodes.Count != 0)
{
currentNode = queueOfNodes.Dequeue();
layInRange = true;
dimension = currentNode.getLevel() % this._numberOfKeys;
for (int keyNumber = 0; keyNumber < this._numberOfKeys; ++keyNumber)
{
if (lowerBound[keyNumber].CompareTo(currentNode.Keys[keyNumber]) <= 0 &&
upperBound[keyNumber].CompareTo(currentNode.Keys[keyNumber]) >= 0)
{
continue;
}
else
{
layInRange = false;
break;
}
}
if (layInRange)
{
result.AddLast(currentNode);
}
if (lowerBound[dimension].CompareTo(currentNode.Keys[dimension]) <= 0)
{
tmpNode = currentNode.LeftSon;
if (tmpNode != null)
{
queueOfNodes.Enqueue(tmpNode);
}
}
if (currentNode.Keys[dimension].CompareTo(upperBound[dimension]) <= 0)
{
tmpNode = currentNode.RightSon;
if (tmpNode != null)
{
queueOfNodes.Enqueue(tmpNode);
}
}
}
return(result);
}
/**
* Metóda umožňuje vymazanie prvku, ktorý je poslaný do funkcie ako parameter. Pred mazaním
* je preto potrebné zavolať metódu search a nájsť prvok, ktorý chceme vymazať.
*
* @param deletedNode
* obsahuje referenciu na vrchol stromu, ktorý sa má odstrániť.
*
* @return vracia hodnotu boolean v závislosti od toho, či sa podarilo prvok vymazať.
*/
protected bool Delete(KDTreeNode <K, T, P> deletedNode)
{
// Inicializácia dočasných premenných, ktoré su počas behu používané.
KDTreeNode <K, T, P> tmpNode = deletedNode;
KDTreeNode <K, T, P> parentNode;
LinkedList <KDTreeNode <K, T, P> > tmpList;
while (true)
{
if (deletedNode.isLeaf())
{
parentNode = deletedNode.Parent;
if (parentNode != null)
{
if (parentNode.LeftSon == deletedNode)
{
parentNode.LeftSon = null;
}
else if (parentNode.RightSon == deletedNode)
{
parentNode.RightSon = null;
}
deletedNode.Parent = null;
}
else
{
this.Root = null;
}
--Count;
return(true);
}
tmpList = FindMaximal(deletedNode, true);
int maximalDepth = 0;
if (tmpList.Count != 0)
{
tmpNode = tmpList.First.Value;
deletedNode.Keys = tmpNode.Keys;
deletedNode.Data = tmpNode.Data;
deletedNode.PrimaryKey = tmpNode.PrimaryKey;
deletedNode = tmpNode;
}
else
{
tmpList = FindMaximal(deletedNode, false);
if (tmpList.Count != 0)
{
tmpNode = tmpList.First.Value;
deletedNode.Keys = tmpNode.Keys;
deletedNode.Data = tmpNode.Data;
deletedNode.PrimaryKey = tmpNode.PrimaryKey;
if (deletedNode.LeftSon == null)
{
deletedNode.LeftSon = deletedNode.RightSon;
deletedNode.RightSon = null;
}
deletedNode = tmpNode;
}
}
}
}
