/// <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;
}
