public BinaryTreeItem Find(int? itemToFind, BinaryTreeItem actItem = null)
{
if (_root == null)
{
return null;
}
if (actItem == null)
{
actItem = _root;
}
if (actItem.Item < itemToFind)
{
if (actItem.ItemRight == null)
{
return null;
}
actItem = actItem.ItemRight;
return Find(itemToFind, actItem);
}
else if (actItem.Item > itemToFind)
{
if (actItem.ItemLeft == null)
{
return null;
}
actItem = actItem.ItemLeft;
return Find(itemToFind, actItem);
}
else
{
return actItem;
}
/*
BinaryTreeItem actItem = _root;
while(actItem != null)
{
if(actItem.Item == itemToFind)
{
return actItem;
}
if(itemToFind > actItem.Item)
{
actItem = actItem.ItemRight;
}
else if(itemToFind < actItem.Item)
{
actItem = actItem.ItemLeft;
}
}
return null;
*/
}
//Find
public BinaryTreeItem FindItem(int itemToFind)
{
//1.Fall
if (this._root == null)
{
return null;
}
//2.Fall
BinaryTreeItem tmp = this._root;
while (tmp != null)
{
if (tmp.Item > itemToFind)
{
tmp = tmp.NextLeftItem;
}
if (tmp.Item < itemToFind)
{
tmp = tmp.NextRightItem;
}
if (tmp.Item == itemToFind)
{
return tmp;
}
}
return null;
}
public BinaryTreeItem Find_Rekursiv(int?itemToFind, BinaryTreeItem actItem = null)
{
if (itemToFind == null)
{
return(null);
}
if (actItem == null)
{
actItem = _root;
}
if (actItem.ItemLeft != null || actItem.ItemRight != null)
{
if (itemToFind > actItem.Item)
{
return(Find_Rekursiv(itemToFind, actItem.ItemRight));
}
if (itemToFind < actItem.Item)
{
return(Find_Rekursiv(itemToFind, actItem.ItemLeft));
}
if (itemToFind == actItem.Item)
{
return(actItem);
}
return(null);
}
return(null);
}
public BinaryTreeItem MinimumBefore(int?itemToFind = null)
{
BinaryTreeItem actItem = _root;
if (actItem == null)
{
return(null);
}
if (itemToFind != null)
{
actItem = Find(itemToFind);
}
while (actItem != null)
{
if (actItem.ItemLeft.ItemLeft == null)
{
return(actItem);
}
actItem = actItem.ItemLeft;
}
return(null);
}
private void AddRecursiveIntern(int? itemToAdd, BinaryTreeItem nextValue)
{
if (this._root == null)
{
this._root = new BinaryTreeItem(itemToAdd, null, null);
//counter ++;
return;
}
if (itemToAdd == nextValue.Item)
{
nextValue.Counter++;
//Counter ++;
return;
}
if (itemToAdd < nextValue.Item)
{
if (nextValue.NextLeftItem == null)
{
nextValue.NextLeftItem = new BinaryTreeItem(itemToAdd, null, null);
//counter ++;
return;
}
AddRecursiveIntern(itemToAdd, nextValue.NextLeftItem);
}
else if (itemToAdd > nextValue.Item)
{
if (nextValue.NextRightItem == null)
{
nextValue.NextRightItem = new BinaryTreeItem(itemToAdd, null, null);
}
}
AddRecursiveIntern(itemToAdd, nextValue.NextRightItem);
}
// Max
public BinaryTreeItem Maximum(int MaxItem, BinaryTreeItem actItem = null)
{
if ((MaxItem == 0) || (this._root == null))
{
return(null);
}
//Maxitem in der Liste finden
BinaryTreeItem foundItem = Find(MaxItem);
if (foundItem == null)
{
return(null);
}
//actItem zum weiterlaufen der Liste
if (actItem == null)
{
actItem = foundItem;
}
//gibt es ein größeres Item
if (actItem.rightItem != null)
{
actItem = actItem.rightItem;
}
//Überprüfen & Stop für Rekursion
if (actItem.rightItem == null)
{
return(actItem);
}
else
{
return(Maximum(MaxItem, actItem));
}
}
//Min
public BinaryTreeItem Minimum(int itemToFind)
{
if (this._root == null)
{
return(null);
}
BinaryTreeItem foundItem = FindItem(itemToFind);
if (foundItem == null)
{
return(null);
}
while (foundItem != null)
{
if (foundItem.Item.Equals(itemToFind))
{
if (foundItem.NextLeftItem != null)
{
foundItem = foundItem.NextLeftItem;
}
}
return(foundItem);
}
return(null);
}
// Min
public BinaryTreeItem Minimum(int MinItem, BinaryTreeItem actItem = null)
{
if ((MinItem == 0) || (this._root == null))
{
return(null);
}
//MinItem in der Liste finden
BinaryTreeItem foundItem = Find(MinItem);
if (foundItem == null)
{
return(null);
}
//actItem zum weiterlaufen der Liste
if (actItem == null)
{
actItem = foundItem;
}
//wenn es etwas kleineres gibt
if (actItem.leftItem != null)
{
actItem = actItem.leftItem;
}
//überprüfen & Stop für Rekursion
if (actItem.leftItem == null)
{
return(actItem);
}
else
{
return(Minimum(MinItem, actItem));
}
}
//FindBefore
public BinaryTreeItem FindBefore(int itemToFind, out bool isRoot)
{
isRoot = false;
if (this._root == null)
{
return(null);
}
if (this._root.Item == itemToFind)
{
isRoot = true;
return(null);
}
BinaryTreeItem tmp = this._root;
while (tmp != null)
{
if (tmp.NextLeftItem.Item > itemToFind)
{
tmp = tmp.NextLeftItem;
}
if (tmp.NextRightItem.Item < itemToFind)
{
tmp = tmp.NextRightItem;
}
if ((tmp.NextLeftItem.Item == itemToFind) || (tmp.NextRightItem.Item == itemToFind))
{
return(tmp);
}
}
return(null);
}
public BinaryTreeItem(int?item, int counter, BinaryTreeItem leftItem, BinaryTreeItem rightItem)
{
this.Item = item;
this.Counter = counter;
this.ItemLeft = leftItem;
this.ItemRight = rightItem;
}
public BinaryTreeItem Maximum(int?itemToFind)
{
BinaryTreeItem actItem = _root;
if (actItem == null)
{
return(null);
}
if (itemToFind != null)
{
actItem = Find(itemToFind);
}
while (actItem != null)
{
if (actItem.ItemRight == null)
{
return(actItem);
}
actItem = actItem.ItemRight;
}
return(null);
}
public void Add(int?itemToAdd)
{
if (itemToAdd == 0)
{
return;
}
//1.Fall: Tree ist leer:
if (_root == null)
{
_root = new BinaryTreeItem(itemToAdd, 1, null, null);
_count++;
}
else
{
BinaryTreeItem actItemPrevious = null;
BinaryTreeItem actItem = _root;
while (actItem != null)
{
//2.Fall: ItemToAdd = actItem
if (itemToAdd == actItem.Item)
{
actItem.Counter++;
_count++;
return;
}
actItemPrevious = actItem;
//3.Fall: itemToAdd > actItem
if (itemToAdd > actItem.Item)
{
actItem = actItem.ItemRight;
}
//4.Fall: itemToAdd <= actItem
else
{
actItem = actItem.ItemLeft;
}
}
if (actItemPrevious.Item < itemToAdd)
{
actItemPrevious.ItemRight = new BinaryTreeItem(itemToAdd, 1, null, null);
_count++;
}
else
{
actItemPrevious.ItemLeft = new BinaryTreeItem(itemToAdd, 1, null, null);
_count++;
}
}
//ToString()
}
/*public BinaryTreeItem FindBefore(int? itemToFind, BinaryTreeItem actItem = null)
{
if (_root == null)
{
return null;
}
if (actItem == null)
{
actItem = _root;
}
if ((actItem.ItemLeft.Item == itemToFind) || (actItem.ItemRight.Item == itemToFind))
{
return actItem;
}
else
{
if (actItem.Item < itemToFind)
{
actItem = actItem.ItemRight;
return FindBefore(itemToFind, actItem);
}
else
{
actItem = actItem.ItemLeft;
return FindBefore(itemToFind, actItem);
}
}
}
*/
public BinaryTreeItem Minimum(int? itemToFind = null, BinaryTreeItem actItem = null)
{
if (_root == null)
{
return null;
}
if (actItem == null)
{
if (itemToFind != null)
{
actItem = Find(itemToFind.Value);
}
else
{
actItem = _root;
}
}
else
{
actItem = actItem.ItemLeft;
}
if (actItem.ItemLeft == null)
{
return actItem;
}
else
{
return Minimum(itemToFind, actItem);
}
/*
BinaryTreeItem actItem = _root;
if(actItem == null)
{
return null;
}
if (itemToFind != null)
{
actItem = Find(itemToFind);
}
while (actItem != null)
{
if (actItem.ItemLeft == null)
{
return actItem;
}
actItem = actItem.ItemLeft;
}
return null;
*/
}
//FIND-rekursiv
public BinaryTreeItem FindRecursive(int? itemToFind, BinaryTreeItem currentValue)
{
if (this._root == null)
{
return null;
}
return FindRecursiveIntern(itemToFind, _root);
}
public BinaryTreeItem FindItemBefore(double?itemToFind)
{
BinaryTreeItem itemBefore = null;
if (itemToFind == null)
{
return(null);
}
if (this._root == null)
{
return(null);
}
if (this._root.Item == itemToFind)
{
return(null);
}
BinaryTreeItem actItem = this._root;
while (actItem != null)
{
if (itemToFind > actItem.Item)
{
if (actItem.ItemRight.Item == itemToFind)
{
itemBefore = actItem;
return(itemBefore);
}
else
{
actItem = actItem.ItemRight;
}
}
if (itemToFind < actItem.Item)
{
if (actItem.ItemLeft.Item == itemToFind)
{
itemBefore = actItem;
return(itemBefore);
}
else
{
actItem = actItem.ItemLeft;
}
}
if (actItem.ItemLeft == null || actItem.ItemRight == null)
{
return(null);
}
}
return(null);
}
public BinaryTreeItem(int?item, BinaryTreeItem leftitem, BinaryTreeItem rightitem)
{
this.Item = item;
this.leftItem = leftitem;
this.rightItem = rightitem;
if (item == null)
{
this.Counter = 0;
}
else
{
this.Counter = 1;
}
}
public BinaryTreeItem(int?item, BinaryTreeItem nextRightItem, BinaryTreeItem nextLeftItem)
{
this.Item = item;
this.NextLeftItem = nextLeftItem;
this.NextRightItem = nextRightItem;
if (item == null)
{
this.Counter = 0;
}
else
{
this.Counter = 1;
}
}
//neues Kommentar
//Add
public void Add(int? itemToAdd)
{
if (itemToAdd == null)
{
return;
}
if (this._root == null)
{
this._root = new BinaryTreeItem(itemToAdd, null, null);
return;
}
BinaryTreeItem tmp = this._root;
while (tmp != null)
{
if (tmp.Item.Equals(itemToAdd))
{
tmp.Counter++;
return;
}
if (itemToAdd > tmp.Item)
{
if (tmp.NextRightItem == null)
{
tmp.NextRightItem = new BinaryTreeItem(itemToAdd, null, null);
return;
}
tmp = tmp.NextRightItem;
}
if (itemToAdd < tmp.Item)
{
if (tmp.NextLeftItem == null)
{
tmp.NextLeftItem = new BinaryTreeItem(itemToAdd, null, null);
return;
}
tmp = tmp.NextLeftItem;
}
}
}
public BinaryTreeItem Find(int?itemToFind, BinaryTreeItem actItem = null)
{
if (actItem == null)
{
actItem = _root;
}
if (actItem.Item < itemToFind)
{
actItem = actItem.ItemRight;
return(Find(itemToFind, actItem));
}
else if (actItem.Item > itemToFind)
{
actItem = actItem.ItemLeft;
return(Find(itemToFind, actItem));
}
else
{
return(actItem);
}
/*BinaryTreeItem actItem = _root;
*
* while(actItem != null)
* {
* if(actItem.Item == itemToFind)
* {
* return actItem;
* }
*
* if(itemToFind > actItem.Item)
* {
* actItem = actItem.ItemRight;
* }
* else if(itemToFind < actItem.Item)
* {
* actItem = actItem.ItemLeft;
* }
*
* }
*
* return null;
*/
}
public BinaryTreeItem Minimum(int?itemToFind = null, BinaryTreeItem actItem = null)
{
if (_root == null)
{
return(null);
}
if (actItem == null)
{
actItem = _root;
}
else
{
actItem = actItem.ItemLeft;
}
if (actItem.ItemLeft != null)
{
return(Minimum(itemToFind, actItem));
}
else
{
return(actItem);
}
/*
* BinaryTreeItem actItem = _root;
* if(actItem == null)
* {
* return null;
* }
*
* if (itemToFind != null)
* {
* actItem = Find(itemToFind);
* }
*
* while (actItem != null)
* {
* if (actItem.ItemLeft == null)
* {
* return actItem;
* }
* actItem = actItem.ItemLeft;
* }
*
* return null;
*/
}
public BinaryTreeItem Maximum(int? itemToFind, BinaryTreeItem actItem = null)
{
if (_root == null)
{
return null;
}
if (actItem == null)
{
if (itemToFind != null)
{
while (actItem.Item < itemToFind)
{
actItem = actItem.ItemRight;
}
}
actItem = _root;
}
else
{
actItem = actItem.ItemRight;
}
if (actItem.ItemRight == null)
{
return actItem;
}
else
{
return Maximum(itemToFind, actItem);
}
/*
while (actItem != null)
{
if (actItem.ItemRight == null)
{
return actItem;
}
actItem = actItem.ItemRight;
}
return null;
*/
}
// Add Rek.
public bool AddRek(int itemToAdd, BinaryTreeItem actItem = null)
{
//Liste gibt es nicht
if (this._root == null)
{
this._root = new BinaryTreeItem(itemToAdd, null, null);
return(true);
}
//größer, kleiner, gleich vergleich
if (actItem == null)
{
actItem = this._root;
}
if ((itemToAdd < actItem.Item) && (actItem.leftItem != null))
{
actItem = actItem.leftItem;
}
else if ((itemToAdd > actItem.Item) && (actItem.leftItem != null))
{
actItem = actItem.leftItem;
}
if ((actItem.rightItem == null) && (itemToAdd > actItem.Item))
{
actItem.rightItem = new BinaryTreeItem(itemToAdd, null, null);
return(true);
}
else if ((actItem.leftItem == null) && (itemToAdd < actItem.Item))
{
actItem.leftItem = new BinaryTreeItem(itemToAdd, null, null);
return(true);
}
else if (actItem.Item.Equals(itemToAdd))
{
actItem.Counter++;
return(true);
}
else
{
return(AddRek(itemToAdd, actItem));
}
}
public BinaryTreeItem Maximum_Rekursiv(int?itemToFind = null, BinaryTreeItem actItem = null)
{
if (actItem == null)
{
actItem = _root;
}
if (itemToFind != null)
{
actItem = Find_Rekursiv(itemToFind);
itemToFind = null;
}
if (actItem.ItemRight != null)
{
return(Maximum_Rekursiv(itemToFind, actItem.ItemRight));
}
else
{
return(actItem);
}
}
//Max
public BinaryTreeItem Maximum()
{
if (this._root == null)
{
return null;
}
BinaryTreeItem tmp = this._root;
while (tmp != null)
{
if (tmp.Item != null)
{
tmp = tmp.NextRightItem;
}
return tmp;
}
return null;
}
private BinaryTreeItem MinimumrekursiveIntern(int? startValue = null, BinaryTreeItem actItem = null)
{
if (actItem == null)
{
if (startValue != null)
{
actItem = FindItem(startValue.Value);
}
else
{
actItem = this._root;
}
}
else
{
actItem = actItem.NextLeftItem;
}
if (actItem == null)
{
return null;
}
if (actItem.NextLeftItem == null)
{
return actItem;
}
else
{
return MinimumrekursiveIntern(startValue, actItem);
}
}
// Find
public BinaryTreeItem Find(int itemToFind, BinaryTreeItem actItem = null)
{
if ((itemToFind == 0) || (this._root == null))
{
return(null);
}
if (actItem == null)
{
actItem = this._root;
}
if (actItem.Item > itemToFind)
{
actItem = actItem.leftItem;
}
else if (actItem.Item < itemToFind)
{
actItem = actItem.rightItem;
}
else
{
return(actItem);
}
if (actItem == null)
{
return(null);
}
else if (actItem.Item.Equals(itemToFind))
{
return(actItem);
}
else
{
return(Find(itemToFind, actItem));
}
}
public BinaryTreeItem Maximum(int?itemToFind, BinaryTreeItem actItem = null)
{
if (_root == null)
{
return(null);
}
if (actItem == null)
{
actItem = _root;
}
else
{
actItem = actItem.ItemRight;
}
if (actItem.ItemRight != null)
{
return(Maximum(itemToFind, actItem));
}
else
{
return(actItem);
}
/*
* while (actItem != null)
* {
* if (actItem.ItemRight == null)
* {
* return actItem;
* }
* actItem = actItem.ItemRight;
* }
*
* return null;
*/
}
private BinaryTreeItem FindRecursiveIntern(int? itemToFind, BinaryTreeItem currentValue)
{
if (this._root == null)
{
return null;
}
if (itemToFind == currentValue.Item)
{
return currentValue;
}
else if (itemToFind < currentValue.Item)
{
return FindRecursiveIntern(itemToFind, currentValue.NextRightItem);
}
else if (itemToFind > currentValue.Item)
{
return FindRecursiveIntern(itemToFind, currentValue.NextLeftItem);
}
return null;
}
public BinaryTreeItem Find(int?itemToFind)
{
BinaryTreeItem actItem = _root;
while (actItem != null)
{
if (actItem.Item == itemToFind)
{
return(actItem);
}
if (itemToFind > actItem.Item)
{
actItem = actItem.ItemRight;
}
else if (itemToFind < actItem.Item)
{
actItem = actItem.ItemLeft;
}
}
return(null);
}
// Max Rek.
public BinaryTreeItem MaximumRecursiv(int?startValue = null, BinaryTreeItem actItem = null)
{
//bei "ersten" Aufruf ist actItem null
if (actItem == null)
{
//falls startValue != null ist, suchen wir das Element im Baum und setzen das actItem
if (startValue != null)
{
actItem = Find(startValue.Value);
}
//ansonsten starten wir bei _root
else
{
actItem = this._root;
}
}
//bei allen weiteren Aufrufen, setzen wir den Zeiger auf den RightItem
else
{
actItem = actItem.rightItem;
}
if (actItem == null)
{
return(null);
}
//Minimum wurde gefunden
if (actItem.rightItem == null)
{
return(actItem);
}
else
{
return(MaximumRecursiv(startValue, actItem));
}
}
