public static ArrayIterator <T> SetDifference <T>(
this ArrayIterator <T> first1,
ArrayIterator <T> last1,
ArrayIterator <T> first2,
ArrayIterator <T> last2,
ArrayIterator <T> result,
Func <T, T, bool> comp
)
{
while (first1.NotEqual(last1) && first2.NotEqual(last2))
{
if (comp(first1.GetCurrent(), first2.GetCurrent()))
{
result.SetCurrent(first1.GetCurrent());
result = result.GetNext();
first1 = first1.GetNext();
}
else if (comp(first2.GetCurrent(), first1.GetCurrent()))
{
first2 = first2.GetNext();
}
else
{
first1 = first1.GetNext();
first2 = first2.GetNext();
}
}
return(first1.Copy(last1, result));
}
public static ArrayIterator <T> Merge <T>(
this ArrayIterator <T> first1,
ArrayIterator <T> last1,
ArrayIterator <T> first2,
ArrayIterator <T> last2,
ArrayIterator <T> result,
Func <T, T, bool> comp
)
{
while (true)
{
if (first1.IsEqual(last1))
{
return(first2.Copy(last2, result));
}
if (first2.IsEqual(last2))
{
return(first1.Copy(last1, result));
}
if (comp(first2.GetCurrent(), first1.GetCurrent()))
{
result.SetCurrent(first2.GetCurrent());
first2 = first2.GetNext();
}
else
{
result.SetCurrent(first1.GetCurrent());
first1 = first1.GetNext();
}
result = result.GetNext();
}
}
public static bool IsPermutation <T>(
this ArrayIterator <T> first1,
ArrayIterator <T> last1,
ArrayIterator <T> first2,
Func <T, T, bool> pred
)
{
first1.Mismatch(last1, first2, pred, out first1, out first2);
if (first1.IsEqual(last1))
{
return(true);
}
var last2 = first2;
last2 = last2.GetAdvanced(first1.Distance(last1));
for (var it1 = first1; it1.NotEqual(last1); it1 = it1.GetNext())
{
if (first1.Find(it1, it1.GetCurrent(), pred).IsEqual(it1))
{
var n = first2.Count(last2, it1.GetCurrent(), pred);
if (n == 0 || it1.Count(last1, it1.GetCurrent(), pred) != n)
{
return(false);
}
}
}
return(true);
}
public static ArrayIterator <T> Partition <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
Func <T, bool> pred
)
{
while (first.NotEqual(last))
{
while (pred(first.GetCurrent()))
{
first = first.GetNext();
if (first.IsEqual(last))
{
return(first);
}
}
do
{
last = last.GetPrev();
if (first.IsEqual(last))
{
return(first);
}
} while (pred(last.GetCurrent()) == false);
first.Swap(last);
first = first.GetNext();
}
return(first);
}
public static ArrayIterator <T> SearchN <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
int count,
T val,
Func <T, T, bool> pred
)
{
var limit = first.GetAdvanced(first.Distance(last) - count);
while (first.NotEqual(limit))
{
var it = first;
var i = 0;
while (pred(val, it.GetCurrent()))
{
it = it.GetNext();
if (++i == count)
{
return(first);
}
}
first = first.GetNext();
}
return(last);
}
public static ArrayIterator <T> UpperBound <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
T val,
Func <T, T, bool> comp
)
{
var count = Distance(first, last);
while (count > 0)
{
var it = first;
var step = count / 2;
it = it.GetAdvanced(step);
if (comp(val, it.GetCurrent()) == false)
{
it = it.GetNext();
first = it;
count -= step + 1;
}
else
{
count = step;
}
}
return(first);
}
public static void Sort <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
Func <T, T, bool> comp
)
{
// Quicksort
if (first.IsEqual(last))
{
return;
}
var sep = first;
for (var i = first.GetNext(); i.NotEqual(last); i = i.GetNext())
{
if (comp(i.GetCurrent(), first.GetCurrent()))
{
sep = sep.GetNext();
sep.Swap(i);
}
}
first.Swap(sep);
first.Sort(sep, comp);
sep.GetNext().Sort(last, comp);
}
public static ArrayIterator <T> UniqueCopy <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
ArrayIterator <T> result,
Func <T, T, bool> pred
)
{
if (first.IsEqual(last))
{
return(last);
}
result.SetCurrent(first.GetCurrent());
while ((first = first.GetNext()).NotEqual(last))
{
var val = first.GetCurrent();
if (pred(result.GetCurrent(), val) == false)
{
result = result.GetNext();
result.SetCurrent(val);
}
}
result = result.GetNext();
return(result);
}
public static void PartitionCopy <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
ArrayIterator <T> resultTrue,
ArrayIterator <T> resultFalse,
Func <T, bool> pred,
out ArrayIterator <T> outResultTrue,
out ArrayIterator <T> outResultFalse
)
{
while (first.NotEqual(last))
{
if (pred(first.GetCurrent()))
{
resultTrue.SetCurrent(first.GetCurrent());
resultTrue = resultTrue.GetNext();
}
else
{
resultFalse.SetCurrent(first.GetCurrent());
resultFalse = resultFalse.GetNext();
}
first = first.GetNext();
}
outResultTrue = resultTrue;
outResultFalse = resultFalse;
}
public static void Swap <T>(this ArrayIterator <T> a, ArrayIterator <T> b)
{
var temp = a.GetCurrent();
a.SetCurrent(b.GetCurrent());
b.SetCurrent(temp);
}
public static void MinMaxElement <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
Func <T, T, bool> comp,
out ArrayIterator <T> min,
out ArrayIterator <T> max
)
{
if (first.IsEqual(last))
{
min = last;
max = last;
}
min = first;
max = first;
while ((first = first.GetNext()).NotEqual(last))
{
if (comp(first.GetCurrent(), min.GetCurrent()))
{
min = first;
}
if (comp(max.GetCurrent(), first.GetCurrent()))
{
max = first;
}
}
}
public static ArrayIterator <T> Search <T>(
this ArrayIterator <T> first1,
ArrayIterator <T> last1,
ArrayIterator <T> first2,
ArrayIterator <T> last2,
Func <T, T, bool> pred
)
{
if (first2.IsEqual(last2))
{
return(first1);
}
while (first1.NotEqual(last1))
{
var it1 = first1;
var it2 = first2;
while (pred(it1.GetCurrent(), it2.GetCurrent()))
{
it1 = it1.GetNext();
it2 = it2.GetNext();
if (it2.IsEqual(last2))
{
return(first1);
}
if (it1.IsEqual(last1))
{
return(last1);
}
}
first1 = first1.GetNext();
}
return(last1);
}
public static ArrayIterator <T> IsHeapUntil <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
Func <T, T, bool> comp
)
{
var len = first.Distance(last);
var p = 0;
var c = 1;
var pp = first;
while (c < len)
{
var cp = first.GetAdvanced(c);
if (comp(pp.GetCurrent(), cp.GetCurrent()))
{
return(cp);
}
c++;
cp = cp.GetNext();
if (c == len)
{
return(last);
}
if (comp(pp.GetCurrent(), cp.GetCurrent()))
{
return(cp);
}
p++;
pp = pp.GetNext();
c = 2 * p + 1;
}
return(last);
}
public static bool PrevPermutation <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
Func <T, T, bool> comp
)
{
var i = last;
if (first.IsEqual(last) || first.IsEqual(i = i.GetPrev()))
{
return(false);
}
while (true)
{
var ip1 = i;
if (comp(ip1.GetCurrent(), (i = i.GetPrev()).GetCurrent()))
{
var j = last;
while (comp((j = j.GetPrev()).GetCurrent(), i.GetCurrent()) == false)
{
}
Swap(i, j);
Reverse(ip1, last);
return(true);
}
if (i.IsEqual(first))
{
Reverse(first, last);
return(false);
}
}
}
public static ArrayIterator <T> PartitionPoint <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
Func <T, bool> pred
)
{
var n = first.Distance(last);
while (n > 0)
{
var it = first;
var step = n / 2;
it.GetAdvanced(step);
if (pred(it.GetCurrent()))
{
first = it.GetNext();
n -= step + 1;
}
else
{
n = step;
}
}
return(first);
}
public static void StableSort <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
Func <T, T, bool> comp
)
{
// TODO find a faster algorithm that doesn't create any garbage than insertion sort
var arr = first.Array;
for (var i = first.Index + 1; i < last.Index; i++)
{
var x = arr[i];
var left = first.Index;
var right = i - 1;
while (left <= right)
{
var middle = (left + right) / 2;
if (comp(x, arr[middle]))
{
right = middle - 1;
}
else
{
left = middle + 1;
}
}
for (var j = i - 1; j >= left; j--)
{
arr[j + 1] = arr[j];
}
arr[left] = x;
}
}
public static void Reverse <T>(this ArrayIterator <T> first, ArrayIterator <T> last)
{
while ((first.NotEqual(last)) && (first.NotEqual((last = last.GetPrev()))))
{
first.Swap(last);
first = first.GetNext();
}
}
public static bool IsHeap <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
Func <T, T, bool> comp
)
{
return(first.IsHeapUntil(last, comp).IsEqual(last));
}
public static ArrayIterator <T> RotateCopy <T>(
this ArrayIterator <T> first,
ArrayIterator <T> middle,
ArrayIterator <T> last,
ArrayIterator <T> result
)
{
result = Copy(middle, last, result);
return(Copy(first, middle, result));
}
public static bool BinarySearch <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
T val,
Func <T, T, bool> comp
)
{
first = first.LowerBound(last, val, comp);
return(first.NotEqual(last) && comp(val, first.GetCurrent()) == false);
}
public static void PartialSort <T>(
this ArrayIterator <T> first,
ArrayIterator <T> middle,
ArrayIterator <T> last,
Func <T, T, bool> comp
)
{
// TODO find a faster algorithm that doesn't create any garbage
first.Sort(last, comp);
}
public static void NthElement <T>(
this ArrayIterator <T> first,
ArrayIterator <T> nth,
ArrayIterator <T> last,
Func <T, T, bool> comp
)
{
// TODO find a faster algorithm that doesn't create any garbage
first.Sort(last, comp);
}
public static void ForEach <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
Action <T> callback
)
{
while (first.NotEqual(last))
{
callback(first.GetCurrent());
first = first.GetNext();
}
}
public static void EqualRange <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
T val,
Func <T, T, bool> comp,
out ArrayIterator <T> lower,
out ArrayIterator <T> upper
)
{
lower = first.LowerBound(last, val, comp);
upper = lower.UpperBound(last, val, comp);
}
public static void SortHeap <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
Func <T, T, bool> comp
)
{
while (first.Distance(last) > 1)
{
last = last.GetPrev();
Swap(first, last);
AdjustHeap(first.Array, first.Index, first.Index, last.Index, comp);
}
}
public static void RandomShuffle <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
Func <int, int> gen
)
{
var n = Distance(first, last);
for (var i = n - 1; i > 0; --i)
{
first.GetAdvanced(i).Swap(first.GetAdvanced(gen(i + 1)));
}
}
public static ArrayIterator <T> SwapRanges <T>(
this ArrayIterator <T> first1,
ArrayIterator <T> last1,
ArrayIterator <T> first2
)
{
while (first1.NotEqual(last1))
{
Swap(first1, first2);
first1 = first1.GetNext();
first2 = first2.GetNext();
}
return(first2);
}
public static void PopHeap <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
Func <T, T, bool> comp
)
{
if (first.Distance(last) < 2)
{
return;
}
last = last.GetPrev();
Swap(first, last);
AdjustHeap(first.Array, first.Index, first.Index, last.Index, comp);
}
public static ArrayIterator <T> CopyBackward <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
ArrayIterator <T> result
)
{
while (last.NotEqual(first))
{
result = result.GetPrev();
last = last.GetPrev();
result.SetCurrent(last.GetCurrent());
}
return(result);
}
public static ArrayIterator <T> ReverseCopy <T>(
this ArrayIterator <T> first,
ArrayIterator <T> last,
ArrayIterator <T> result
)
{
while (first.NotEqual(last))
{
last = last.GetPrev();
result.SetCurrent(last.GetCurrent());
result = result.GetNext();
}
return(result);
}
