static void Stabilize <T>(T[] data, BaseSort sort) where T : IComparable <T>
{
Wrapper <T>[] items = new Wrapper <T> [data.Length];
for (int i = 0; i < data.Length; i++)
{
items[i] = new Wrapper <T>(i, data[i]);
}
sort.Sort(items);
Console.Write("Index:\t");
for (int i = 0; i < items.Length; i++)
{
Console.Write(items[i].Index + " ");
}
Console.WriteLine();
Console.Write("Elem:\t");
for (int i = 0; i < items.Length; i++)
{
Console.Write(items[i].Key + " ");
}
Console.WriteLine();
Console.WriteLine();
int index = 0;
while (index < items.Length - 1)
{
while (index < items.Length - 1 &&
items[index].Key.Equals(items[index + 1].Key))
{
// 插入排序
for (int j = index + 1; j > 0 && items[j].Index < items[j - 1].Index; j--)
{
if (!items[j].Key.Equals(items[j - 1].Key))
{
break;
}
Wrapper <T> temp = items[j];
items[j] = items[j - 1];
items[j - 1] = temp;
}
index++;
}
index++;
}
Console.Write("Index:\t");
for (int i = 0; i < items.Length; i++)
{
Console.Write(items[i].Index + " ");
}
Console.WriteLine();
Console.Write("Elem:\t");
for (int i = 0; i < items.Length; i++)
{
Console.Write(items[i].Key + " ");
}
Console.WriteLine();
}
static bool CheckStability <T>(T[] data, BaseSort sort) where T : IComparable <T>
{
var items = new Wrapper <T> [data.Length];
for (var i = 0; i < data.Length; i++)
{
items[i] = new Wrapper <T>(i, data[i]);
}
sort.Sort(items);
var index = 0;
while (index < data.Length - 1)
{
while (index < data.Length - 1 && items[index].Key.Equals(items[index + 1].Key))
{
if (items[index].Index > items[index + 1].Index)
{
return(false);
}
index++;
}
index++;
}
return(true);
}
/// <summary>
/// 对相应排序算法执行一次耗时测试。
/// </summary>
/// <param name="sort">用于测试的排序算法。</param>
/// <param name="a">用于测试的数据。</param>
/// <returns>排序的耗时，单位为毫秒。</returns>
public static double Time <T>(BaseSort sort, T[] a) where T : IComparable <T>
{
var stopwatch = Stopwatch.StartNew();
sort.Sort(a);
return(stopwatch.ElapsedMilliseconds);
}
/// <summary>
/// 构造一个绘图结果窗口。
/// </summary>
/// <param name="sort">用于做测试的排序算法。</param>
/// <param name="n">用于测试的初始数据量。</param>
public Form2(BaseSort sort, int n)
{
InitializeComponent();
_sort = sort;
_result = Test(n);
timer1.Interval = 1000;
timer1.Start();
}
/// <summary>
/// 构造只有一个元素的数组并用其对指定排序算法做测试。
/// </summary>
/// <param name="sort">需要做测试的排序算法。</param>
/// <returns>排序算法的耗时。</returns>
static double OneArraySizeSort(BaseSort sort)
{
int[] array = new int[1];
Random random = new Random();
array[0] = random.Next();
return(SortCompare.Time(sort, array));
}
/// <summary>
/// 构造逆序数组并用其对指定输入算法进行测试。
/// </summary>
/// <param name="sort">需要做测试的算法。</param>
/// <returns>算法耗时。</returns>
static double ReverseSortTest(BaseSort sort)
{
int[] array = new int[10000];
for (int i = 0; i < array.Length; i++)
{
array[i] = array.Length - i;
}
return(SortCompare.Time(sort, array));
}
/// <summary>
/// 构造只有两种取值的数组并用其对指定排序算法做测试。
/// </summary>
/// <param name="sort">需要做测试的排序算法。</param>
/// <returns>排序算法的耗时。</returns>
static double BinarySortTest(BaseSort sort)
{
int[] array = new int[10000];
Random random = new Random();
for (int i = 0; i < array.Length; i++)
{
array[i] = random.Next(2);
}
return(SortCompare.Time(sort, array));
}
/// <summary>
/// 构造一个绘制结果窗口。
/// </summary>
/// <param name="sort">用于测试的排序算法。</param>
/// <param name="n">测试算法是生成的数据量。</param>
public Form2(BaseSort sort, int n)
{
InitializeComponent();
resultList = new List <double>();
resultYList = new List <float>();
clientRect = ClientRectangle;
drawRect = new Rectangle(clientRect.X + 10, clientRect.Y + 10, clientRect.Width - 10, clientRect.Height - 10);
this.sort = sort;
this.n = n;
timer1.Interval = 500;
timer1.Start();
}
/// <summary>
/// 构造只有一个值的数组并用其对指定排序算法做测试。
/// </summary>
/// <param name="sort">需要做测试的排序算法。</param>
/// <returns>算法的耗时。</returns>
static double EqualSortTest(BaseSort sort)
{
var array = new int[10000];
var random = new Random();
var num = random.Next();
for (var i = 0; i < array.Length; i++)
{
array[i] = num;
}
return(SortCompare.Time(sort, array));
}
static void Test(BaseSort sort, int n, int constant)
{
Item <int>[] array = new Item <int> [n];
for (int i = 0; i < n; i++)
{
array[i] = new Item <int>(i, constant);
}
sort.Sort(array);
for (int i = 0; i < n; i++)
{
Console.Write(array[i].Index + " ");
}
Console.WriteLine();
}
public void BaseSortTest()
{
// arrange
var baseSort = new BaseSort <int>(Items);
// act
baseSort.Sort();
// assert
for (int i = 0; i < Items.Count; i++)
{
Assert.AreEqual(Sorted[i], baseSort.Items[i]);
}
}
/// <summary>
/// 对相应排序算法做多次有序数据测试，返回总耗时。
/// </summary>
/// <param name="sort">用于测试的排序算法。</param>
/// <param name="n">每次测试的数据量。</param>
/// <param name="trials">测试次数。</param>
/// <returns>多次排序的总耗时，单位为毫秒。</returns>
public static double TimeSortedInput(BaseSort sort, int n, int trials)
{
var total = 0.0;
var a = new double[n];
for (var t = 0; t < trials; t++)
{
for (var i = 0; i < n; i++)
{
a[i] = i * 1.0;
}
total += Time(sort, a);
}
return(total);
}
/// <summary>
/// 对相应排序算法做多次随机数据测试，返回总耗时。
/// </summary>
/// <param name="sort">用于测试的排序算法。</param>
/// <param name="n">每次测试的数据量。</param>
/// <param name="trials">测试次数。</param>
/// <returns>多次排序的总耗时，单位为毫秒。</returns>
public static double TimeRandomInput(BaseSort sort, int n, int trials)
{
var total = 0.0;
var a = new double[n];
var random = new Random();
for (var t = 0; t < trials; t++)
{
for (var i = 0; i < n; i++)
{
a[i] = random.NextDouble();
}
total += Time(sort, a);
}
return(total);
}
/// <summary>
/// 构造已排序的数组并用其对指定排序算法测试。
/// </summary>
/// <param name="sort">需要做测试的排序算法。</param>
/// <returns>算法的耗时。</returns>
static double SortedSortTest(BaseSort sort)
{
return(SortCompare.TimeSortedInput(sort, 10000, 1));
}
/// <summary>
/// 构造空数组并用其对指定排序算法做测试。
/// </summary>
/// <param name="sort">需要做测试的排序算法。</param>
/// <returns>排序算法的耗时。</returns>
static double ZeroArraySizeSort(BaseSort sort)
{
int[] array = new int[0];
return(SortCompare.Time(sort, array));
}
public SortingTests()
{
baseSortDates = new SelectionSort <DateTime>();
}
public Context(BaseSort strategy)
{
this._strategy = strategy;
}
