/// <summary> /// Возвращает геометрическую разность (элементы, не входящие в пересечение) текущего множества с указанным. /// Типы множеств - SortedLinkedList, т.е. используется реализация списков. /// </summary> /// <param name="B">Второе множество</param> /// <returns>Новое множество элементов. (может быть пустым)</returns> public SortedLinkedList <T> SymmetricDifference(SortedLinkedList <T> B) { SortedLinkedList <T> ANB = Difference(B); //A\B SortedLinkedList <T> BNA = B.Difference(this); //B\A return(ANB.Union(BNA)); }
/// <summary> /// Возвращает разность текущего множества с указанным. /// Типы множеств - SortedLinkedList, т.е. используется реализация списков. /// </summary> /// <param name="B">Второе множество</param> /// <returns>Новое множество элементов. (может быть пустым)</returns> public SortedLinkedList <T> Difference(SortedLinkedList <T> B) { SortedLinkedList <T> sll = new SortedLinkedList <T>(_comp);//C. __Difference(_head, B._head, out sll._head, ref sll._tail, ref sll._count); return(sll); }
/// <summary> /// Возвращает объединение текущего множества с указанным. /// Типы множеств - SortedLinkedList, т.е. используется реализация списков. /// </summary> /// <param name="B">Второе множество</param> /// <returns>Новое множество элементов. (может быть пустым)</returns> public SortedLinkedList <T> Union(SortedLinkedList <T> B) { SortedLinkedList <T> sll = new SortedLinkedList <T>(_comp);//C. __Union(_head, B._head, out sll._head, ref sll._tail, ref sll._count); return(sll); }
//RETRIEVE(RANGE) where RANGE IS [l,r] (0,0) returns this[0] /// <summary> /// Получить подмножество элементов множества, начиная с индекса l /// и заканчивая индексом r включительно. (Индексы отсчитываются с нуля). /// </summary> /// <param name="l">Левая граница, отсчитываемая с нуля.</param> /// <param name="r">Правая граница, отсчитываемая с нуля.</param> /// <returns>Подмножество элементов, или null, если границы указаны неверно.</returns> public SortedLinkedList <T> GetRange(Int32 l, Int32 r) { if (l >= _count || l < 0) { Console.WriteLine("left bound is out of range"); return(null); } if (r >= _count || r < 0 || r < l) { Console.WriteLine("right bound is out of range"); return(null); } ElementType <T> b = _head; Int32 i = -1; SortedLinkedList <T> R = new SortedLinkedList <T>(_comp); while (i < l) { b = b.Next; i++; } while (i <= r) { R.__AddO(b.Element); b = b.Next; i++; } return(R); }
/* * public bool Add(T item){ * Int32 t = _count; * Add(item); * if(_count > t) * return true; * return false; * }*/ /// <summary> /// Определяет, содержит ли множества общие элементы. /// </summary> /// <param name="other">Другое множество на основе набора элементов.</param> /// <returns>true - если да, иначе false.</returns> public bool Overlaps(IEnumerable <T> other) { SortedLinkedList <T> B = new SortedLinkedList <T>(other, _comp); SortedLinkedList <T> sll = new SortedLinkedList <T>(_comp);//C. __Intersection(_head, B._head, out sll._head, ref sll._tail, ref sll._count); return(sll.Count != 0); }
/// <summary> /// Определяет, равны ли множества (текущее и указанное), т.е. содержат одни и те же элементы. /// </summary> /// <param name="other">Другое множество на основе набора элементов.</param> public bool SetEquals(IEnumerable <T> other) { if (other == null) { return(false); } SortedLinkedList <T> B = new SortedLinkedList <T>(other, _comp); return(Equals(B)); }
/// <summary> /// Возвращает пересечение текущего множества с указанным. /// Типы множеств - SortedLinkedList, т.е. используется реализация списков. /// </summary> /// <param name="B">Второе множество</param> /// <returns>Новое множество элементов. (может быть пустым)</returns> public SortedLinkedList <T> Intersection(SortedLinkedList <T> B) //MAKE PARAM_TYPE COMMON { SortedLinkedList <T> sll = new SortedLinkedList <T>(_comp); //C. if (B.Count == 0) //B = Empty. { return(sll); } __Intersection(_head, B._head, out sll._head, ref sll._tail, ref sll._count); return(sll); }
public ISet <T> Merge(ISet <T> A, ISet <T> B) { if (A.Overlaps(B)) { return(null); } ISet <T> C = new SortedLinkedList <T>(); C.UnionWith(A); C.UnionWith(B); return(C); }
/// <summary> /// Возвращает слияние уникальных элементов текущего множества с указанным. /// Типы множеств - SortedLinkedList, т.е. используется реализация списков. /// </summary> /// <param name="B">Второе множество</param> /// <returns>Новое множество элементов, если пересечение исходных множеств было пустым, иначе null.</returns> public SortedLinkedList <T> Merge(SortedLinkedList <T> B) { SortedLinkedList <T> C = Intersection(B); if (C.Count != 0) { return(null); } SortedLinkedList <T> R = Union(B); return(R); }
//EQUALS(A,B) /// <summary> /// Проверяет, что множества содержат одинаковые элементы. /// </summary> /// <param name="B">Второе множество.</param> /// <returns>true если множества равны, иначе false.</returns> public bool Equals(SortedLinkedList <T> B) { if (B == null) { return(false); } if (Intersection(B)._count == _count) { return(true); } else { return(false); } }
///<summary>Наследуется от Object. ///Определяет, эквиваленты ли два множества.</summary> public override bool Equals(Object obj) { if (obj == null) { return(false); } SortedLinkedList <T> list = obj as SortedLinkedList <T>; if (list == null) { return(false); } else { return(Equals(list)); } }
/// <summary> /// Определяет, является ли текущее множество надмножеством указанного. /// (Т.е. содержит ли в себе текущее набор элементов other). /// </summary> /// <param name="other">Другое множество на основе набора элементов.</param> public bool IsSupersetOf(IEnumerable <T> other) { if (other.Count() == 0) { return(true); } SortedLinkedList <T> B = new SortedLinkedList <T>(other, _comp); ElementType <T> _nh; ElementType <T> _nt = new ElementType <T>(); Int32 c = 0; __Difference(B._head, _head, out _nh, ref _nt, ref c);//B\A if (c == 0) { return(true); } return(false); }
/// <summary> /// Оставляет в текущем множестве только те элементы, /// которых нет в другом указанном множестве. /// </summary> /// <param name="other">Другое множество на основе набора элементов.</param> public void ExceptWith(IEnumerable <T> other) { SortedLinkedList <T> B = new SortedLinkedList <T>(other, _comp); if (B.Count == 0) { return; } ElementType <T> _nh; ElementType <T> _nt = new ElementType <T>(); Int32 c = 0; __Difference(_head, B._head, out _nh, ref _nt, ref c); this._count = 0; this._head = _nh; this._tail = _nt; this._count = c; }
/// <summary> /// Оставляет в текущем множестве только те элементы, /// которые есть в другом указанном множестве. /// </summary> /// <param name="other">Другое множество на основе набора элементов.</param> public void IntersectWith(IEnumerable <T> other) { SortedLinkedList <T> B = new SortedLinkedList <T>(other, _comp); if (B.Count == 0) { Clear(); return; } ElementType <T> _nh; ElementType <T> _nt = new ElementType <T>(); Int32 c = 0; __Intersection(_head, B._head, out _nh, ref _nt, ref c); this._count = 0; this._head = _nh; this._tail = _nt; this._count = c; }
/// <summary> /// Оставляет в текущем множестве только те элементы, /// которые не содержатся одновременно в двух множествах (текущем и указанном) /// </summary> /// <param name="other">Другое множество на основе набора элементов.</param> public void SymmetricExceptWith(IEnumerable <T> other) { SortedLinkedList <T> B = new SortedLinkedList <T>(other, _comp); if (B.Count == 0) { return; } B = B.Difference(this); // B\A ExceptWith(other); // A\B ElementType <T> _nh; ElementType <T> _nt = new ElementType <T>(); Int32 c = 0; __Union(_head, B._head, out _nh, ref _nt, ref c); this._count = c; this._head = _nh; this._tail = _nt; }