private void Push(SetItem <K> node) { while (!node.IsEmpty) { stack.Push(node); node = Prev(node); } }
public SetEnumerator(SetItem <K> root, bool rev, int start) { this.rev = rev; this.start = start; map = root; stack = pool.GetItem(); Reset(); }
/// <summary> /// Ctor /// </summary> internal SetItem(byte height, int count, K key, SetItem <K> left, SetItem <K> right) { Count = count; Height = height; Key = key; Left = left; Right = right; }
public SetEnumerator(SetItem <K> root, bool rev, int start) { this.rev = rev; this.start = start; map = root; stack = Pool <NewStack, SetItem <K>[]> .Pop(); Reset(); }
private void Push(SetItem <K> node) { while (!node.IsEmpty) { stack[stackDepth] = node; stackDepth++; node = Prev(node); } }
/// <summary> /// Ctor that takes an initial (distinct) set of items /// </summary> /// <param name="items"></param> internal SetInternal(IEnumerable <A> items, SetModuleM.AddOpt option) { set = SetItem <A> .Empty; foreach (var item in items) { set = SetModuleM.Add <OrdA, A>(set, item, option); } }
public static SetItem <K> Balance <K>(SetItem <K> node) => node.BalanceFactor >= 2 ? node.Right.BalanceFactor < 0 ? DblRotLeft(node) : RotLeft(node) : node.BalanceFactor <= -2 ? node.Left.BalanceFactor > 0 ? DblRotRight(node) : RotRight(node) : node;
internal Set(IEnumerable <T> items) { set = SetItem <T> .Empty; // TODO: Perf foreach (var item in items) { set = SetModule.Add(set, item, Comparer <T> .Default); } }
public SetInternal <OrdA, A> AddOrUpdateRange(IEnumerable <A> xs) { var set = this; foreach (var x in xs) { set = set.AddOrUpdate(x); } return(set); }
public SetInternal <OrdA, A> TryAddRange(IEnumerable <A> xs) { var set = this; foreach (var x in xs) { set = set.TryAdd(x); } return(set); }
public static S FoldBack <S, K>(SetItem <K> node, S state, Func <S, K, S> folder) { if (node.IsEmpty) { return(state); } state = FoldBack(node.Right, state, folder); state = folder(state, node.Key); state = FoldBack(node.Left, state, folder); return(state); }
public bool MoveNext() { if (left > 0 && stack.Count > 0) { NodeCurrent = stack.Pop(); Push(Next(NodeCurrent)); left--; return(true); } NodeCurrent = null; return(false); }
public bool MoveNext() { if (left > 0 && stackDepth > 0) { stackDepth--; NodeCurrent = stack[stackDepth]; Push(Next(NodeCurrent)); left--; return(true); } NodeCurrent = null; return(false); }
public static SetItem <K> Balance <K>(SetItem <K> node) { node.Height = (byte)(1 + Math.Max(node.Left.Height, node.Right.Height)); node.Count = 1 + node.Left.Count + node.Right.Count; return(node.BalanceFactor >= 2 ? node.Right.BalanceFactor < 0 ? DblRotLeft(node) : RotLeft(node) : node.BalanceFactor <= -2 ? node.Left.BalanceFactor > 0 ? DblRotRight(node) : RotRight(node) : node); }
/// <summary> /// Ctor that takes an initial (distinct) set of items /// </summary> /// <param name="items"></param> internal Set(IEnumerable <T> items, bool checkUniqueness = false) { set = SetItem <T> .Empty; if (checkUniqueness) { foreach (var item in items) { set = SetModule.TryAdd(set, item, Comparer <T> .Default); } } else { foreach (var item in items) { set = SetModule.Add(set, item, Comparer <T> .Default); } } }
/// <summary> /// Ctor that takes an initial (distinct) set of items /// </summary> /// <param name="items"></param> internal SetInternal(IEnumerable <A> items, bool tryAdd) { set = SetItem <A> .Empty; if (tryAdd) { foreach (var item in items) { set = SetModule.TryAdd <OrdA, A>(set, item); } } else { foreach (var item in items) { set = SetModule.Add <OrdA, A>(set, item); } } }
public static SetItem <K> RotLeft <K>(SetItem <K> node) { if (node.IsEmpty || node.Right.IsEmpty) { return(node); } var x = node; var y = x.Right; var t2 = y.Left; y.Left = x; x.Right = t2; x.Height = (byte)(1 + Math.Max(x.Left.Height, x.Right.Height)); y.Height = (byte)(1 + Math.Max(y.Left.Height, y.Right.Height)); x.Count = 1 + x.Left.Count + x.Right.Count; y.Count = 1 + y.Left.Count + y.Right.Count; return(y); }
public SetInternal <OrdA, A> AddOrUpdateRange(IEnumerable <A> xs) { if (xs == null) { return(this); } if (Count == 0) { return(new SetInternal <OrdA, A>(xs, SetModuleM.AddOpt.TryUpdate)); } var set = this; foreach (var x in xs) { set = set.AddOrUpdate(x); } return(set); }
public static bool Contains <OrdK, K>(SetItem <K> node, K key) where OrdK : struct, Ord <K> { if (node.IsEmpty) { return(false); } var cmp = default(OrdK).Compare(key, node.Key); if (cmp < 0) { return(Contains <OrdK, K>(node.Left, key)); } else if (cmp > 0) { return(Contains <OrdK, K>(node.Right, key)); } else { return(true); } }
public static SetItem <K> Remove <K>(SetItem <K> node, K key, Comparer <K> comparer) { if (node.IsEmpty) { return(node); } var cmp = comparer.Compare(key, node.Key); if (cmp < 0) { return(Balance(Make(node.Key, Remove(node.Left, key, comparer), node.Right))); } else if (cmp > 0) { return(Balance(Make(node.Key, node.Left, Remove(node.Right, key, comparer)))); } else { return(Balance(AddTreeToRight(node.Left, node.Right))); } }
public static Option <K> TryFind <K>(SetItem <K> node, K key, Comparer <K> comparer) { if (node.IsEmpty) { return(None); } var cmp = comparer.Compare(key, node.Key); if (cmp < 0) { return(TryFind(node.Left, key, comparer)); } else if (cmp > 0) { return(TryFind(node.Right, key, comparer)); } else { return(Some(node.Key)); } }
public static SetItem <K> TryAdd <K>(SetItem <K> node, K key, Comparer <K> comparer) { if (node.IsEmpty) { return(new SetItem <K>(1, 1, key, SetItem <K> .Empty, SetItem <K> .Empty)); } var cmp = comparer.Compare(key, node.Key); if (cmp < 0) { return(Balance(Make(node.Key, TryAdd(node.Left, key, comparer), node.Right))); } else if (cmp > 0) { return(Balance(Make(node.Key, node.Left, TryAdd(node.Right, key, comparer)))); } else { return(node); } }
public static SetItem <K> Add <K>(SetItem <K> node, K key, Comparer <K> comparer) { if (node.IsEmpty) { return(new SetItem <K>(1, 1, key, SetItem <K> .Empty, SetItem <K> .Empty)); } var cmp = comparer.Compare(key, node.Key); if (cmp < 0) { return(Balance(Make(node.Key, Add(node.Left, key, comparer), node.Right))); } else if (cmp > 0) { return(Balance(Make(node.Key, node.Left, Add(node.Right, key, comparer)))); } else { throw new ArgumentException("An element with the same key already exists in the set"); } }
public static Option <K> TryFind <OrdK, K>(SetItem <K> node, K key) where OrdK : struct, Ord <K> { if (node.IsEmpty) { return(None); } var cmp = default(OrdK).Compare(key, node.Key); if (cmp < 0) { return(TryFind <OrdK, K>(node.Left, key)); } else if (cmp > 0) { return(TryFind <OrdK, K>(node.Right, key)); } else { return(Some(node.Key)); } }
public static K Find <K>(SetItem <K> node, K key, Comparer <K> comparer) { if (node.IsEmpty) { throw new ArgumentException("Key not found in set"); } var cmp = comparer.Compare(key, node.Key); if (cmp < 0) { return(Find(node.Left, key, comparer)); } else if (cmp > 0) { return(Find(node.Right, key, comparer)); } else { return(node.Key); } }
public static SetItem <K> Add <OrdK, K>(SetItem <K> node, K key) where OrdK : struct, Ord <K> { if (node.IsEmpty) { return(new SetItem <K>(1, 1, key, SetItem <K> .Empty, SetItem <K> .Empty)); } var cmp = default(OrdK).Compare(key, node.Key); if (cmp < 0) { return(Balance(Make(node.Key, Add <OrdK, K>(node.Left, key), node.Right))); } else if (cmp > 0) { return(Balance(Make(node.Key, node.Left, Add <OrdK, K>(node.Right, key)))); } else { throw new ArgumentException("An element with the same key already exists in the set"); } }
public static SetItem <K> Remove <OrdK, K>(SetItem <K> node, K key) where OrdK : struct, Ord <K> { if (node.IsEmpty) { return(node); } var cmp = default(OrdK).Compare(key, node.Key); if (cmp < 0) { return(Balance(Make(node.Key, Remove <OrdK, K>(node.Left, key), node.Right))); } else if (cmp > 0) { return(Balance(Make(node.Key, node.Left, Remove <OrdK, K>(node.Right, key)))); } else { return(Balance(AddTreeToRight(node.Left, node.Right))); } }
public static SetItem <K> AddOrUpdate <OrdK, K>(SetItem <K> node, K key) where OrdK : struct, Ord <K> { if (node.IsEmpty) { return(new SetItem <K>(1, 1, key, SetItem <K> .Empty, SetItem <K> .Empty)); } var cmp = default(OrdK).Compare(key, node.Key); if (cmp < 0) { return(Balance(Make(node.Key, TryAdd <OrdK, K>(node.Left, key), node.Right))); } else if (cmp > 0) { return(Balance(Make(node.Key, node.Left, TryAdd <OrdK, K>(node.Right, key)))); } else { return(new SetItem <K>(node.Height, node.Count, key, node.Left, node.Right)); } }
public static K Find <OrdK, K>(SetItem <K> node, K key) where OrdK : struct, Ord <K> { if (node.IsEmpty) { throw new ArgumentException("Key not found in set"); } var cmp = default(OrdK).Compare(key, node.Key); if (cmp < 0) { return(Find <OrdK, K>(node.Left, key)); } else if (cmp > 0) { return(Find <OrdK, K>(node.Right, key)); } else { return(node.Key); } }
public static bool Contains <K>(SetItem <K> node, K key, Comparer <K> comparer) { if (node.IsEmpty) { return(false); } var cmp = comparer.Compare(key, node.Key); if (cmp < 0) { return(Contains(node.Left, key, comparer)); } else if (cmp > 0) { return(Contains(node.Right, key, comparer)); } else { return(true); } }