private TreeDictionary <TKey, TValue, TComparer> Balanced(TValue value, TreeDictionary <TKey, TValue, TComparer> left, TreeDictionary <TKey, TValue, TComparer> right) { return(EqualityComparer <TValue> .Default.Equals(_value, value) && ReferenceEquals(_left, left) && ReferenceEquals(_right, right) ? this : Balanced(_key, value, left, right)); }
private TreeDictionary <TKey, TValue, TComparer> AddRecursive(TKey key, TValue value, ref bool needRebalance) { if (_count == 0) { needRebalance = true; return(TreeDictionary.Single <TKey, TValue, TComparer>(key, value)); } int comparison = _Comparer.Compare(key, _key); if (comparison == 0) { needRebalance = false; return(ReplaceValue(value)); } if (comparison < 0) { var newLeft = _left.AddRecursive(key, value, ref needRebalance); return(needRebalance ? NearlyBalanced(newLeft, _right) : Balanced(newLeft, _right)); } else { var newRight = _right.AddRecursive(key, value, ref needRebalance); return(needRebalance ? NearlyBalanced(_left, newRight) : Balanced(_left, newRight)); } }
private void SplitRecursive( TKey key, out TreeDictionary <TKey, TValue, TComparer> less, out Optional <TValue> value, out TreeDictionary <TKey, TValue, TComparer> greater) { if (Count == 0) { less = Empty; value = Optional <TValue> .None; greater = Empty; return; } int comparison = _Comparer.Compare(key, _key); if (comparison == 0) { less = _left; value = Optional.Some(_value); greater = _right; return; } if (comparison < 0) { _left.SplitRecursive(key, out less, out value, out greater); greater = Unbalanced(_key, _value, greater, _right); return; } else { _right.SplitRecursive(key, out less, out value, out greater); less = Unbalanced(_key, _value, _left, less); return; } }
private TreeDictionary <TKey, TValue, TComparer> Balanced( TreeDictionary <TKey, TValue, TComparer> left, TreeDictionary <TKey, TValue, TComparer> right) { return(ReferenceEquals(_left, left) && ReferenceEquals(_right, right) ? this : Balanced(_key, _value, left, right)); }
private static TreeDictionary <TKey, TValue, TComparer> RotateRight( TKey key, TValue value, TreeDictionary <TKey, TValue, TComparer> left, TreeDictionary <TKey, TValue, TComparer> right) { return(left._right.Count() < RATIO *left._left.Count() ? RotateSingleRight(key, value, left, right) : RotateDoubleRight(key, value, left, right)); }
private static TreeDictionary <TKey, TValue, TComparer> RotateSingleRight( TKey key, TValue value, TreeDictionary <TKey, TValue, TComparer> left, TreeDictionary <TKey, TValue, TComparer> right) { return(Balanced( left._key, left._value, left._left, Balanced(key, value, left._right, right))); }
private TreeDictionary <TKey, TValue, TComparer> InsertMax(TKey key, TValue value) { if (Count == 0) { return(TreeDictionary.Single <TKey, TValue, TComparer>(key, value)); } return(NearlyBalanced(_left, _right.InsertMax(key, value))); }
/// <summary> /// Returns a dictionary with the same keys. The value for each key is /// obtained by calling <c>func(key, this[key])</c>. /// </summary> /// <typeparam name="TValue1">The type of the values in the returned dictionary.</typeparam> /// <param name="func">The function mapped.</param> /// <returns>The resulting dictionary.</returns> public TreeDictionary <TKey, TValue1, TComparer> Map <TValue1>(Func <TKey, TValue, TValue1> func) { if (Count == 0) { return(TreeDictionary <TKey, TValue1, TComparer> .Empty); } return(TreeDictionary <TKey, TValue1, TComparer> .Balanced( _key, func(_key, _value), _left.Map(func), _right.Map(func))); }
internal TreeDictionary( int count, TKey key, TValue value, TreeDictionary <TKey, TValue, TComparer> left, TreeDictionary <TKey, TValue, TComparer> right) { _count = count; _right = right; _left = left; _value = value; _key = key; AssertInvariant(); }
private static TreeDictionary <TKey, TValue, TComparer> RotateDoubleLeft( TKey key, TValue value, TreeDictionary <TKey, TValue, TComparer> left, TreeDictionary <TKey, TValue, TComparer> right) { TreeDictionary <TKey, TValue, TComparer> rightLeft = right._left; return(Balanced( rightLeft._key, rightLeft._value, Balanced(key, value, left, rightLeft._left), Balanced(right._key, right._value, rightLeft._right, right._right))); }
private static TreeDictionary <TKey, TValue, TComparer> RotateDoubleRight( TKey key, TValue value, TreeDictionary <TKey, TValue, TComparer> left, TreeDictionary <TKey, TValue, TComparer> right) { var leftRight = left._right; return(Balanced( leftRight._key, leftRight._value, Balanced(left._key, left._value, left._left, leftRight._left), Balanced(key, value, leftRight._right, right))); }
/// <summary> /// Updates values of all keys. For each key in the dictionary, the /// value is replaced with <code>func(key, this[key])</code>. /// </summary> /// <typeparam name="TValue1">The type of the values in the returned dictionary.</typeparam> /// <param name="func">The updating function.</param> /// <returns>The resulting dictionary.</returns> public TreeDictionary <TKey, TValue1, TComparer> MapPartial <TValue1>(Func <TKey, TValue, Optional <TValue1> > func) { if (Count == 0) { return(TreeDictionary <TKey, TValue1, TComparer> .Empty); } var newValue = func(_key, _value); return(newValue.HasValue ? TreeDictionary <TKey, TValue1, TComparer> .Unbalanced(_key, newValue.Value, _left.MapPartial(func), _right.MapPartial(func)) : TreeDictionary <TKey, TValue1, TComparer> .GlueUnbalanced(_left.MapPartial(func), _right.MapPartial(func))); }
/// <summary> /// Indicates whether the current object is equal to another object of /// the same type. Dictionaries are considered equal, if they have the /// same keys and values. /// </summary> /// <returns> /// <c>true</c> if the current object is equal to the /// <paramref name="other"/> parameter; otherwise, <c>false</c>. /// </returns> /// <param name="other">An object to compare with this object. /// </param> public bool Equals(TreeDictionary <TKey, TValue, TComparer> other) { if (ReferenceEquals(null, other)) { return(false); } if (ReferenceEquals(this, other)) { return(true); } return(_count == other._count && this.SequenceEqual(other)); }
private static TreeDictionary <TKey, TValue, TComparer> GlueBalanced( TreeDictionary <TKey, TValue, TComparer> left, TreeDictionary <TKey, TValue, TComparer> right) { if (left.Count() == 0) { return(right); } if (right.Count() == 0) { return(left); } TKey minKeyRight; TValue minKeyValueRight; var newRight = right.FindAndRemoveMinKeyFromNonEmpty(out minKeyRight, out minKeyValueRight); return(NearlyBalanced(minKeyRight, minKeyValueRight, left, newRight)); }
private static TreeDictionary <TKey, TValue, TComparer> GlueUnbalanced( TreeDictionary <TKey, TValue, TComparer> left, TreeDictionary <TKey, TValue, TComparer> right) { if (left.Count() == 0) { return(right); } if (right.Count() == 0) { return(left); } if (DELTA * left.Count <= right.Count) { return(right.NearlyBalanced(GlueUnbalanced(left, right._left), right._right)); } if (DELTA * right.Count <= left.Count) { return(left.NearlyBalanced(left._left, GlueUnbalanced(left._right, right))); } return(GlueBalanced(left, right)); }
private static TreeDictionary <TKey, TValue, TComparer> Unbalanced( TKey key, TValue value, TreeDictionary <TKey, TValue, TComparer> left, TreeDictionary <TKey, TValue, TComparer> right) { if (left.Count() == 0) { return(right.InsertMin(key, value)); } if (right.Count() == 0) { return(left.InsertMax(key, value)); } if (DELTA * left.Count <= right.Count) { return(right.NearlyBalanced(Unbalanced(key, value, left, right._left), right._right)); } if (DELTA * right.Count <= left.Count) { return(left.NearlyBalanced(left._left, Unbalanced(key, value, left._right, right))); } return(Balanced(key, value, left, right)); }
private static TreeDictionary <TKey, TValue, TComparer> NearlyBalanced( TKey key, TValue value, TreeDictionary <TKey, TValue, TComparer> left, TreeDictionary <TKey, TValue, TComparer> right) { int countLeft = left.Count(); int countRight = right.Count(); int count = 1 + countLeft + countRight; if (countLeft + countRight <= 1) { return(new TreeDictionary <TKey, TValue, TComparer>(count, key, value, left, right)); } if (countLeft >= DELTA * countRight) // >= in Data.Map { return(RotateRight(key, value, left, right)); } if (countRight >= DELTA * countLeft) // >= in Data.Map { return(RotateLeft(key, value, left, right)); } // Balanced already return(new TreeDictionary <TKey, TValue, TComparer>(count, key, value, left, right)); }
private TreeDictionary <TKey, TValue, TComparer> UnionTrim( TreeDictionary <TKey, TValue, TComparer> otherDict, TKey low, TKey high, Func <TKey, TValue, TValue, TValue> combiner) { if (otherDict.Count == 0) { return(this); } if (Count == 0) { var otherLeft = otherDict._left.FilterLess(high); var otherRight = otherDict._right.FilterGreater(low); return(ReferenceEquals(otherDict._left, otherLeft) && ReferenceEquals(otherDict._right, otherRight) ? otherDict : otherDict.Unbalanced(otherDict._value, otherLeft, otherRight)); } Debug.Assert(_Comparer.Compare(low, _key) < 0 && _Comparer.Compare(high, _key) > 0); return(Unbalanced( _value, _left.UnionTrim(otherDict.Trim(low, _key), low, _key, combiner), _right.UnionTrim(otherDict.Trim(_key, high), _key, high, combiner))); }
/// <summary> /// Returns the dictionary containing all keys present in both /// dictionaries. The value is obtained by using the /// <paramref name="combiner"/>. /// </summary> /// <param name="otherDict"> /// The other dictionary. /// </param> /// <param name="combiner"> /// The function used for combining values of duplicate keys. /// </param> /// <returns> /// The difference of two dictionaries. /// </returns> public TreeDictionary <TKey, TValue, TComparer> Intersection( TreeDictionary <TKey, TValue, TComparer> otherDict, Func <TKey, TValue, TValue, TValue> combiner) { throw new NotImplementedException(); }
private TreeDictionary( TKey key, TValue value, TreeDictionary <TKey, TValue, TComparer> left, TreeDictionary <TKey, TValue, TComparer> right) : this(1 + left.Count() + right.Count(), key, value, left, right) { }
private static TreeDictionary <TKey, TValue, TComparer> Balanced( TKey key, TValue value, TreeDictionary <TKey, TValue, TComparer> left, TreeDictionary <TKey, TValue, TComparer> right) { return(new TreeDictionary <TKey, TValue, TComparer>(key, value, left, right)); }
private TreeDictionary <TKey, TValue, TComparer> NearlyBalanced(TreeDictionary <TKey, TValue, TComparer> left, TreeDictionary <TKey, TValue, TComparer> right) { return(NearlyBalanced(_key, _value, left, right)); }
public TreeDictionary <TKey, TValue, TComparer> Difference( TreeDictionary <TKey, TValue, TComparer> otherDict) { throw new NotImplementedException(); }
/// <summary> /// Returns the dictionary containing all keys present in both /// dictionaries. The value from <c>this</c> dictionary is used. /// </summary> /// <param name="otherDict"> /// The other dictionary. /// </param> /// <param name="combiner"> /// The function used for combining values of duplicate keys. /// </param> /// <returns> /// The difference of two dictionaries. /// </returns> public TreeDictionary <TKey, TValue, TComparer> IntersectionLeftBiased(TreeDictionary <TKey, TValue, TComparer> otherDict) { throw new NotImplementedException(); }