public ITreeSortNode <T> Insert(T aValue) { if (root == null) { if (DuplicateHandling == DuplicateHandlingType.CollectDuplicates) { root = new MultiInstanceAVLTreeSortNode <T> (aValue, Sentinel); } else { root = new SingleInstanceAVLTreeSortNode <T> (aValue, Sentinel); } NodeCount++; return(root); } else { ITreeSortNode <T> newNode = null; if (Root.InsertNode(args, ref root, aValue, out newNode) == true) { return(newNode); } return(null); } }
private int IndexOf(IAVLTreeSortNode <T> aNode, T aValue, int aIdx) { if (aNode.IsSentinel == true) { return(-1); } int compare = OnSortMethod(aNode.Value, aValue); if (compare > 0) { return(IndexOf(aNode.LowValueChild, aValue, aIdx)); } else if (compare < 0) { return(IndexOf(aNode.HighValueChild, aValue, aIdx + aNode.InstanceCount + aNode.LowWeight)); } else { for (int i = 0; i < aNode.InstanceCount; i++) { if (aNode[i].Equals(aValue) == true) { return(aIdx + i); } } return(-1); } }
public void Remove(T aValue, InstanceInformation aInstances) { lock (this) { Deleted = null; if (((DuplicateHandling == DuplicateHandlingType.CollectDuplicates) && (aInstances != InstanceInformation.AllInstances)) || (aInstances == InstanceInformation.ObjectInstance)) { IAVLTreeSortNode <T> t = FindAndMark(aValue); if (t == null) { return; } if (t.InstanceCount > 1) { t.RemoveValue(aValue); } else { Remove(aValue, InstanceInformation.AllInstances); } return; } Root.Delete(args, ref root, aValue); } }
// constuctor for the sentinel node internal AVLTreeSortNode() { level = SENTINEL_ID; lowValueChild = this; highValueChild = this; InitStore(); }
private IAVLTreeSortNode <T> FindAndMark(IAVLTreeSortNode <T> aNode, T aValue) { if (aNode.IsSentinel == true) { return(null); } int compare = OnSortMethod(aNode.Value, aValue); IAVLTreeSortNode <T> res = null; if (compare > 0) { res = FindAndMark(aNode.LowValueChild, aValue); } else if (compare < 0) { res = FindAndMark(aNode.HighValueChild, aValue); } else { aNode.Weight = -1; return(aNode); } if (res != null) { aNode.Weight = -1; } return(res); }
// constuctor for regular nodes (that all start life as leaf nodes) internal AVLTreeSortNode(T aValue, IAVLTreeSortNode <T> aSentinel) { level = 1; weight = -1; lowValueChild = aSentinel; highValueChild = aSentinel; InitStore(); AddValue(aValue); }
public bool Delete(SortEventArgs <T> aArgs, ref IAVLTreeSortNode <T> aNode, T value) { if (aNode == aArgs.Tree.Sentinel) { return(aArgs.Tree.Deleted != null); } int compare = -aArgs.OnCompare(value, aNode.Value); if (compare < 0) { if (Delete(aArgs, ref (aNode as AVLTreeSortNode <T, Store>).highValueChild, value) == false) { return(false); } (aNode as AVLTreeSortNode <T, Store>).HighValueChild.Weight = -1; } else { if (compare == 0) { aArgs.Tree.Deleted = aNode; } if (Delete(aArgs, ref (aNode as AVLTreeSortNode <T, Store>).lowValueChild, value) == false) { return(false); } (aNode as AVLTreeSortNode <T, Store>).LowValueChild.Weight = -1; } if (aArgs.Tree.Deleted != null) { aArgs.Tree.DeletedNode = aArgs.Tree.Deleted; aArgs.Tree.Deleted = null; aNode = aNode.LowValueChild; aNode.Weight = -1; aNode.LowValueChild.Weight = -1; } else if ((aNode.HighValueChild.Level < aNode.Level - 1) || (aNode.LowValueChild.Level < aNode.Level - 1)) { --aNode.Level; if (aNode.LowValueChild.Level > aNode.Level) { aNode.LowValueChild.Level = aNode.Level; } Skew(ref aNode); Skew(ref (aNode as AVLTreeSortNode <T, Store>).lowValueChild); Skew(ref (aNode.LowValueChild as AVLTreeSortNode <T, Store>).lowValueChild); Split(ref aNode); Split(ref (aNode as AVLTreeSortNode <T, Store>).highValueChild); } return(true); }
public bool InsertNode(SortEventArgs <T> aArgs, ref IAVLTreeSortNode <T> aNode, T value, out ITreeSortNode <T> aNewNode) { aNewNode = null; if (aNode == aArgs.Tree.Sentinel) { aNode = CreateNode(value, aArgs.Tree.Sentinel); aNewNode = aNode; return(true); } int compare = -aArgs.OnCompare(value, aNode.Value); if (compare < 0) { if (InsertNode(aArgs, ref (aNode as AVLTreeSortNode <T, Store>).highValueChild, value, out aNewNode) == false) { return(false); } (aNode as AVLTreeSortNode <T, Store>).HighValueChild.Weight = -1; } else if (compare > 0) { if (InsertNode(aArgs, ref (aNode as AVLTreeSortNode <T, Store>).lowValueChild, value, out aNewNode) == false) { return(false); } (aNode as AVLTreeSortNode <T, Store>).LowValueChild.Weight = -1; } else { switch (aArgs.DuplicateHandling) { case DuplicateHandlingType.CollectDuplicates: aNode.AddValue(value); aNewNode = aNode; return(true); case DuplicateHandlingType.ThrowException: throw new DuplicateItemException(); default: return(false); } return(false); } Weight = -1; Skew(ref aNode); Split(ref aNode); return(true); }
private IAVLTreeSortNode <T> GetNodeFor(IAVLTreeSortNode <T> aNode, int aIdx) { if (aIdx <= aNode.LowWeight) { return(GetNodeFor(aNode.LowValueChild, aIdx)); } else if (aIdx > (aNode.LowWeight + aNode.InstanceCount)) { return(GetNodeFor(aNode.HighValueChild, aIdx - (aNode.LowWeight + aNode.InstanceCount))); } else { return(aNode); } }
internal BaseAVLTreeSort(CompareMethod <T> aSortMethod, DuplicateHandlingType aDuplicateHandling) { sortMethod = aSortMethod; duplicateHandling = aDuplicateHandling; args = CreateSortArgs(); if (DuplicateHandling == DuplicateHandlingType.CollectDuplicates) { sentinel = new MultiInstanceAVLTreeSortNode <T>(); } else { sentinel = new SingleInstanceAVLTreeSortNode <T>(); } //sentinel = new Node<T>(); root = sentinel; deleted = null; }
public virtual IEnumerable Distinct() { IAVLTreeSortNode <T> curr; IAVLTreeSortNode <T> last = null; lock (this) { for (int i = 0; i < Count; i++) { curr = tree.GetNodeFor(i); if ((curr != last) && (curr != null)) { yield return(curr.Value); } last = curr; } } }
private void Skew(ref IAVLTreeSortNode <T> aNode) { if (aNode.Level == aNode.HighValueChild.Level) { // rotate low IAVLTreeSortNode <T> high = aNode.HighValueChild; aNode.HighValueChild.Weight = -1; aNode.HighValueChild = high.LowValueChild; aNode.HighValueChild.Weight = -1; high.LowValueChild = aNode; high.LowValueChild.Weight = -1; aNode = high; aNode.Weight = -1; } }
private void Split(ref IAVLTreeSortNode <T> aNode) { if (aNode.LowValueChild.LowValueChild.Level == aNode.Level) { // rotate high IAVLTreeSortNode <T> low = aNode.LowValueChild; aNode.LowValueChild.Weight = -1; aNode.LowValueChild = low.HighValueChild; aNode.LowValueChild.Weight = -1; low.HighValueChild = aNode; low.HighValueChild.Weight = -1; aNode = low; aNode.Weight = -1; aNode.Level++; } }
private ITreeSortNode <T> Find(IAVLTreeSortNode <T> aNode, T aValue) { if (aNode.IsSentinel == true) { return(null); } int compare = OnSortMethod(aNode.Value, aValue); if (compare > 0) { return(Find(aNode.LowValueChild, aValue)); } else if (compare < 0) { return(Find(aNode.HighValueChild, aValue)); } else { return(aNode); } }
internal MultiInstanceAVLTreeSortNode(T aValue, IAVLTreeSortNode <T> aSentinel) : base(aValue, aSentinel) { }
public override IAVLTreeSortNode <T> CreateNode(T aValue, IAVLTreeSortNode <T> aSentinel) { return(new MultiInstanceAVLTreeSortNode <T> (aValue, aSentinel)); }
public virtual IAVLTreeSortNode <T> CreateNode(T aValue, IAVLTreeSortNode <T> aSentinel) { throw new NotImplementedException(); }
public virtual void Disconnect() { lowValueChild = null; highValueChild = null; }