private void AssetMerge(int[] firstHalf, int[] secondHalf, int[] expectedMergeArray)
{
MergeSort mergeSort = new MergeSort();
var outputArray = mergeSort.Merge(firstHalf, secondHalf);
Assert.IsTrue(outputArray.SequenceEqual(expectedMergeArray));
}
public void TestMerge(int[] arr1, int[] arr2, int[] array)
{
var alg = new MergeSort <int>();
var res = alg.Merge(arr1, arr2);
Assert.Equal(array, res);
}
/// <summary>
/// Selects survivors for the next generation.
/// </summary>
/// <returns>A Fitness-sorted selection of survivors.</returns>
/// <remarks>
/// Assumes the <paramref name="parents"/> and <paramref name="children"/> collections are sorted by fitness.
/// </remarks>
public IEnumerable <IGenotype> SelectSurvivors(IEnumerable <IGenotype> parents, IEnumerable <IGenotype> children)
{
var orderedParents = parents.OrderByDescending(parent => parent.Fitness);
var elite = orderedParents.Take(this.eliteCount);
return(MergeSort.Merge(children, elite, GenotypeComparer));
}
public void Merge()
{
var values1 = new List <int> {
10, 1
};
MergeSort.Merge(values1, 0, 0, 1);
Assert.IsTrue(UtilsTests.IsSortedAscendingly(values1));
var values2 = new List <int> {
10, 1
};
// Indexes are such that the list will not get sorted,
MergeSort.Merge(values2, 0, 1, 1);
Assert.IsTrue(values2[0] == 10);
Assert.IsTrue(values2[1] == 1);
var values3 = new List <int> {
10, 41, 3, 10
};
MergeSort.Merge(values3, 0, 1, 3);
Assert.IsTrue(UtilsTests.IsSortedAscendingly(values3));
}
public void ShouldReturnOrderedArrayWhenTwoOrderedArraysArePassed()
{
var orderedArray1 = new int[] { 2, 3, 5 };
var orderedArray2 = new int[] { 2, 7, 9 };
var result = MergeSort.Merge(orderedArray1, orderedArray2);
Assert.Equal(new int[] { 2, 2, 3, 5, 7, 9 }, result);
}
public void ShouldReturnOrderedArrayWhenTwoNumbersArePassed()
{
var orderedArray1 = new int[] { 2 };
var orderedArray2 = new int[] { 6 };
var result = MergeSort.Merge(orderedArray1, orderedArray2);
Assert.Equal(new int[] { 2, 6 }, result);
}
public void MergeSort_WhengivenValidArray_AlwaysReturnsSorted()
{
var sentance = new char[] { 'e', 'e', 'g', 'm', 'r', 'a', 'c', 'e', 'r', 't' };
var sortedSentance = MergeSort <char> .Merge(sentance);
System.Console.WriteLine(sentance);
System.Console.WriteLine(sortedSentance);
}
static void Main(string[] args)
{
int[] dimensioni = { 20, 50, 100, 500, 1000, 2000, 5000, 10000, 20000, 30000, 40000, 50000, 60000, 100000 };
using (StreamWriter w = new StreamWriter("stat.csv", false, Encoding.UTF8))
{
w.WriteLine("Algoritmo;Dimensione;Tempo");
foreach (int dim in dimensioni)
{
int[] array = new int[dim];
Random rnd = new Random();
for (int i = 0; i < dim; i++)
{
array[i] = rnd.Next(0, 10000000);
}
Stopwatch s = new Stopwatch();
s.Restart();
BubbleSort.Sort(array);
s.Stop();
long elapsed = s.ElapsedMilliseconds;
Console.WriteLine($"BubbleSort:{dim},{elapsed}");
w.WriteLine($"BubbleSort;{dim};{elapsed}");
for (int i = 0; i < array.Length; i++)
{
array[i] = rnd.Next(0, 100000);
}
s.Restart();
Sort.Insert(array);
s.Stop();
elapsed = s.ElapsedMilliseconds;
Console.WriteLine($"InsertionSort:{dim},{elapsed}");
w.WriteLine($"InsertionSort; {dim}; {elapsed}");
for (int i = 0; i < array.Length; i++)
{
array[i] = rnd.Next(0, 100000);
}
s.Restart();
Selection.Sort(array);
s.Stop();
elapsed = s.ElapsedMilliseconds;
Console.WriteLine($"SelectionSort:{dim},{elapsed}");
w.WriteLine($"SelectionSort; {dim}; {elapsed}");
for (int i = 0; i < array.Length; i++)
{
array[i] = rnd.Next(0, 100000);
}
s.Restart();
MergeSort.Merge(array);
s.Stop();
elapsed = s.ElapsedMilliseconds;
Console.WriteLine($"MergeSort:{dim},{elapsed}");
w.WriteLine($"MergeSort;{dim}; {elapsed}");
}
w.Flush();
Console.WriteLine("fine!");
}
Console.ReadLine();
}
private void ChildTaskDone(Processor processor)
{
int decrementedValue = Interlocked.Decrement(ref m_counter);
if (decrementedValue == 0)
{
MergeSort.Merge(m_array, m_start, m_end);
SignalTaskDone(processor);
}
}
public void MergeArray()
{
var sut = new MergeSort <double>();
int size = _Random.Next(100);
var x = GenerateRandomArray(size).OrderBy(t => t).ToArray();
var y = GenerateRandomArray(size).OrderBy(t => t).ToArray();
var result = sut.Merge(x, y);
Assert.That(result, Has.Exactly(size * 2).Items);
Assert.That(result, Is.Ordered.Ascending);
}
private static void Merge(List <object[]> left, List <object[]> right)
{
List <object[]> result = MergeSort.Merge(left, right);
List <object[]> expected = left.Concat(right).ToList();
expected.Sort((val1, val2) => ((IComparable)val1.GetValue(MergeSort.ColumnIndex)).CompareTo(val2.GetValue(MergeSort.ColumnIndex)));
Assert.AreEqual(result.Count, expected.Count);
for (int k = 0; k < result.Count; k++)
{
for (int i = 0; i < result[k].Length; i++)
{
Assert.AreEqual((result[k])[i], (expected[k])[i]);
}
}
}
public void GenericMergeSort_WhenGivenTypeOfCharArray_AlwaysReturnsSorted()
{
var sentance = new char[] { 'd', 'e', 'n', 'n', 'i', 's', 'o', 'c', 'o', 'n', 'n', 'e', 'l', 'l' };
var sortedSentance = MergeSort <char> .Merge(sentance);
}
