public void TestFirstAndLastSort()
{
short[] data = { 10, 7, 3, 1, 9, 7, 4, 3 };
ShellSorter.Sort <short>(data, ShortComparer);
Assert.Equal((short)1, data[0]);
Assert.Equal((short)10, data[7]);
}
/// <summary>
/// 按照指定的门限删除数据
/// </summary>
/// <param name="new_data">需要处理的数据</param>
/// <param name="k">目标门限值</param>
/// <param name="flagNumbers">数据在的下标位置</param>
public void GetThresholdDatas(double[] new_data, double k, string max, out int[] flagNumbers)
{
double[] data_ = new double[new_data.Length];
Array.Copy(new_data, data_, new_data.Length);
data_ = ShellSorter.Sort(data_);
double sd;
while (true)
{
sd = this.GetOffect(data_);
List <double> list = data_.ToList();
if (max == "max")
{
list.Remove(this.GetMax(data_));
}
else
{
list.Remove(this.GetMin(data_));
}
double[] remain_data = new double[list.Count];
Array.Copy(list.ToArray(), remain_data, remain_data.Length);
sd = this.GetOffect(remain_data);
data_ = list.ToArray();
if (sd <= k)
{
double[] remainDatas;
GetDifferentDatas(new_data, data_, out flagNumbers, out remainDatas);
break;
}
}
}
/// <summary>
/// 从数组最小值开始移除元素，直至标准偏差达到指定值
/// </summary>
/// <param name="data"></param>
/// <param name="k"></param>
/// <param name="new_sd_min"></param>
/// <param name="remain"></param>
public void DelErroData_Min(double[] data, double k, out double new_sd_min, out double[] remain)
{
if (k < 0)
{
throw new Exception("k is erro");
}
data = ShellSorter.Sort(data);
double sd = this.GetOffect(data);
int i = 1;
while (true)
{
if (sd < k)
{
new_sd_min = sd;
remain = data;
break;
}
else
{
double[] remain_data = new double[data.Length - i];
Array.Copy(data, i, remain_data, 0, remain_data.Length);
sd = this.GetOffect(remain_data);
i++;
if (sd < k)
{
new_sd_min = sd;
remain = remain_data;
break;
}
}
}
}
public void Test1()
{
var list = new List <int> {
5, 8, 4, 1, 2, 6, 4, 7, 9, 2
};
ShellSorter.ShellSort <int>(list, Comparer <int> .Default);
}
public static void Main(string[] args)
{
Console.WriteLine("Hello! Preparing to sort data.");
short[] data = { 10, 7, 3, 1, 9, 7, 4, 3 };
ShellSorter.Sort <short>(data, ShortComparer);
Console.WriteLine("Finished sorting data. The array contents are: ");
Console.WriteLine(string.Join(",", data));
}
public Researcher(BubleSorter bubleSorter, ShellSorter shellSorter, QuickSorter quickSorter,
MergeSorter mergeSorter,
HeapSorter heapSorter, RadixSorter radixSorter, BuiltInSorter builtInSorter, DataGenerator dataGenerator,
IOptions <ResearcherSettings> options)
{
_dataGenerator = dataGenerator;
_settings = options.Value;
_sorters = new Sorter[]
{
bubleSorter, shellSorter, quickSorter, mergeSorter, heapSorter, radixSorter, builtInSorter
};
}
/// <summary>
/// Обработчик события установки флажка на Shell sorter
/// </summary>
/// <param name="sender">объект инициатор события<</param>
/// <param name="e">параметры события</param>
private void rBtnShell_CheckedChanged(object sender, EventArgs e)
{
if (rBtnShell.Checked)
{
_sort = new ShellSorter(_arr);
_sort.SortingStart += StartSortMessage;
_sort.Swapp += SwapCounting;
_sort.Compare += CompareCounting;
_sort.SortingFin += FinishSortMessage;
}
else
{
_sort = null;
}
}
public static void ArraySorted([Random(0, 1000, 100, Distinct = true)] int n)
{
// Arrange
var sorter = new ShellSorter <int>();
var intComparer = new IntComparer();
var(correctArray, testArray) = RandomHelper.GetArrays(n);
// Act
sorter.Sort(testArray, intComparer);
Array.Sort(correctArray, intComparer);
// Assert
Assert.AreEqual(testArray, correctArray);
}
/// <summary>
/// Creates the sort algorithm implementation.
/// </summary>
/// <param name="algorithm">The algorithm.</param>
/// <returns></returns>
internal static ISortAlgorithm CreateSortAlgorithmImplementation(SortAlgorithm algorithm)
{
ISortAlgorithm toReturn = null;
switch(algorithm)
{
case SortAlgorithm.SelectionSort:
toReturn = new SelectionSorter();
break;
case SortAlgorithm.ShellSort:
toReturn = new ShellSorter();
break;
case SortAlgorithm.QuickSort:
toReturn = new QuickSorter();
break;
}
return toReturn;
}
/// <summary>
/// 按照比例移除部分数据
/// 上下移除
/// </summary>
/// <param name="data">原始数据</param>
/// <param name="k">移除比例</param>
/// <param name="remain">剩下的数据</param>
public void RemoveProportionData(double[] data, double k, out double[] remain)
{
if (k < 0)//移除系数异常
{
throw new Exception("k is erro");
}
int len = Convert.ToInt32(Math.Round(k)) * data.Length;//需要移除的数据长度
data = ShellSorter.Sort(data);
List <double> dataList = data.ToList();
dataList.RemoveRange(0, len);
dataList.RemoveRange(dataList.Count - len - 1, len);
remain = dataList.ToArray();
}
/// <summary>
/// 移除指定的数据后返回一个新的数据
/// 按照最大最小个移除指定的数据
/// </summary>
/// <param name="data"></param>
/// <param name="new_data"></param>
/// <param name="max">指示是否从最大值处开始移除</param>
public void GetRemoveNumData(double[] data, out double[] new_data, bool max)
{
int k = (int)Math.Round(data.Length * 0.1);
int num = data.Length;
data = ShellSorter.Sort(data);
List <double> list = data.ToList();
for (int i = 0; i < k; i++)
{
if (max == true)
{
list.RemoveAt(list.Count - 1);
}
else
{
list.RemoveAt(0);
}
}
new_data = list.ToArray();
}
public void ArraySorted([Random(0, 1000, 1000)] int n)
{
// Arrange
var sorter = new ShellSorter <int>();
var intComparer = new IntComparer();
var random = new Random();
var testArray = new int[n];
var correctArray = new int[n];
for (var i = 0; i < n; i++)
{
var t = random.Next(0, 1000);
testArray[i] = t;
correctArray[i] = t;
}
// Act
sorter.Sort(testArray, intComparer);
Array.Sort(correctArray, intComparer);
// Assert
Assert.AreEqual(testArray, correctArray);
}
public void TestShellSortNullComparer1()
{
ShellSorter <int> sorter = new ShellSorter <int>();
sorter.Sort(new List <int>(), (IComparer <int>)null);
}
static void SortDemo()
{
// seven custom algorithms;
// for each algorithm prepare copies of the same array to sort
Random rd = new Random();
int[] z1 = new int[50000];
for (int i = 0; i < z1.Length; i++)
{
z1[i] = rd.Next(0, z1.Length);
}
int[] z2 = new int[z1.Length];
z1.CopyTo(z2, 0);
int[] z3 = new int[z1.Length];
z1.CopyTo(z3, 0);
int[] z4 = new int[z1.Length];
z1.CopyTo(z4, 0);
int[] z5 = new int[z1.Length];
z1.CopyTo(z5, 0);
int[] z6 = new int[z1.Length];
z1.CopyTo(z6, 0);
int[] z7 = new int[z1.Length];
z1.CopyTo(z7, 0);
// ----------------------------------------------------------
Console.WriteLine("Selection Sort:");
ISorter <int> sorter = new SelectionSorter();
DateTime dt1 = DateTime.Now;
sorter.Sort(z1, 0, z1.Length - 1);
DateTime dt2 = DateTime.Now;
Console.WriteLine("Time: {0}:{1}", (dt2 - dt1).Seconds, (dt2 - dt1).Milliseconds);
Console.WriteLine("First 20 elements:");
foreach (int elem in z1.Take(20))
{
Console.Write(elem + " ");
}
Console.WriteLine();
Console.WriteLine("Bubble sort");
sorter = new BubbleSorter();
dt1 = DateTime.Now;
sorter.Sort(z2, 0, z1.Length - 1);
dt2 = DateTime.Now;
Console.WriteLine("{0}:{1}", (dt2 - dt1).Seconds, (dt2 - dt1).Milliseconds);
Console.WriteLine("First 20 elements:");
foreach (int elem in z2.Take(20))
{
Console.Write(elem + " ");
}
Console.WriteLine();
Console.WriteLine("Insertion sort");
sorter = new InsertionSorter();
dt1 = DateTime.Now;
sorter.Sort(z3, 0, z1.Length - 1);
dt2 = DateTime.Now;
Console.WriteLine("{0}:{1}", (dt2 - dt1).Seconds, (dt2 - dt1).Milliseconds);
Console.WriteLine("First 20 elements:");
foreach (int elem in z3.Take(20))
{
Console.Write(elem + " ");
}
Console.WriteLine();
Console.WriteLine("Shaker sort");
sorter = new ShakerSorter();
dt1 = DateTime.Now;
sorter.Sort(z4, 0, z1.Length - 1);
dt2 = DateTime.Now;
Console.WriteLine("{0}:{1}", (dt2 - dt1).Seconds, (dt2 - dt1).Milliseconds);
Console.WriteLine("First 20 elements:");
foreach (int elem in z4.Take(20))
{
Console.Write(elem + " ");
}
Console.WriteLine();
Console.WriteLine("Shell sort");
sorter = new ShellSorter();
dt1 = DateTime.Now;
sorter.Sort(z5, 0, z1.Length - 1);
dt2 = DateTime.Now;
Console.WriteLine("{0}:{1}", (dt2 - dt1).Seconds, (dt2 - dt1).Milliseconds);
Console.WriteLine("First 20 elements:");
foreach (int elem in z5.Take(20))
{
Console.Write(elem + " ");
}
Console.WriteLine();
Console.WriteLine("Counting sort");
sorter = new CountingSorter();
dt1 = DateTime.Now;
sorter.Sort(z6, 0, z1.Length - 1);
dt2 = DateTime.Now;
Console.WriteLine("{0}:{1}", (dt2 - dt1).Seconds, (dt2 - dt1).Milliseconds);
Console.WriteLine("First 20 elements:");
foreach (int elem in z6.Take(20))
{
Console.Write(elem + " ");
}
Console.WriteLine();
Console.WriteLine("Quicksort");
sorter = new QuickSorter();
dt1 = DateTime.Now;
sorter.Sort(z7, 0, z1.Length - 1);
dt2 = DateTime.Now;
Console.WriteLine("{0}:{1}", (dt2 - dt1).Seconds, (dt2 - dt1).Milliseconds);
Console.WriteLine("First 20 elements:");
foreach (int elem in z7.Take(20))
{
Console.Write(elem + " ");
}
Console.WriteLine();
Console.ReadKey();
Console.Clear();
}
static void Main(string[] args)
{
Console.WriteLine("请选择算法：");
Console.WriteLine("1.选择排序");
Console.WriteLine("2.冒泡排序");
Console.WriteLine("3.高速排序");
Console.WriteLine("4.插入排序");
Console.WriteLine("5.希尔排序");
Console.WriteLine("6.归并排序");
Console.WriteLine("7.基数排序");
Console.WriteLine("8.计数排序");
Console.WriteLine("9.堆排序");
Console.WriteLine("0.退出");
int type = Convert.ToInt32(Console.ReadLine());
string typename = "";
switch (type)
{
case 1: //选择排序
typename = "选择排序";
break;
case 2: //冒泡排序
typename = "冒泡排序";
break;
case 3: //高速排序
typename = "高速排序";
break;
case 4: //插入排序
typename = "插入排序";
break;
case 5: //希尔排序
typename = "希尔排序";
break;
case 6: //归并排序
typename = "归并排序";
break;
case 7: //基数排序
typename = "基数排序";
break;
case 8: //计数排序
typename = "计数排序";
break;
case 9: //堆排序
typename = "堆排序";
break;
default:
typename = "您未选择算法";
break;
}
Console.WriteLine("您选择了{0}.{1}:", type, typename);
int[] arrInt = new int[] { 4, 2, 7, 1, 8, 3, 9, 0, 5, 6 };
int[] intArray = new int[] { 5, 3, 7, 4, 8, 2, 9, 1, 0, 6 };
int[] newIntArray = intArray;
switch (type)
{
case 1: //选择排序
SelectionSorter selSor = new SelectionSorter();
selSor.Sort(arrInt);
foreach (int i in arrInt)
{
Console.WriteLine(i);
}
Console.ReadKey();
break;
case 2: //冒泡排序
EbullitionSorter ebuSor = new EbullitionSorter();
ebuSor.Sort(arrInt);
foreach (int i in arrInt)
{
Console.WriteLine(i);
}
Console.ReadKey();
break;
case 3: //高速排序
QuickSorter quiSor = new QuickSorter();
quiSor.Sort(arrInt, 0, arrInt.Length - 1);
foreach (int i in arrInt)
{
Console.WriteLine(i);
}
Console.ReadKey();
break;
case 4: //插入排序
InsertionSorter insSor = new InsertionSorter();
insSor.Sort(arrInt);
foreach (int i in arrInt)
{
Console.WriteLine(i);
}
Console.ReadKey();
break;
case 5: //希尔排序
ShellSorter sheSor = new ShellSorter();
sheSor.Sort(arrInt);
foreach (int i in arrInt)
{
Console.WriteLine(i);
}
Console.ReadKey();
break;
case 6: //归并排序
while (true)
{
Console.WriteLine("请选择：");
Console.WriteLine("1.归并排序（非递归）");
Console.WriteLine("2.归并排序（递归）");
Console.WriteLine("3.归并排序（自然合并）");
Console.WriteLine("4.退出");
int Arraynum = Convert.ToInt32(Console.ReadLine());
switch (Arraynum)
{
case 4:
Environment.Exit(0);
break;
case 1:
Console.WriteLine("Please Input Array Length");
int Leng271 = Convert.ToInt32(Console.ReadLine());
Function obj1 = new Function(Leng271);
Console.WriteLine("The original sequence:");
Console.WriteLine(obj1);
Console.WriteLine("'MergeSort' Finaly Sorting Result:");
obj1.ToMergeSort();
Console.WriteLine(obj1);
break;
case 2:
Console.WriteLine("Please Input Array Length");
int Leng272 = Convert.ToInt32(Console.ReadLine());
Function obj2 = new Function(Leng272);
Console.WriteLine("The original sequence:");
Console.WriteLine(obj2);
Console.WriteLine("'RecursiveMergeSort' Finaly Sorting Result:");
obj2.ToRecursiveMergeSort();
Console.WriteLine(obj2);
break;
case 3:
Console.WriteLine("Please Input Array Length");
int Leng273 = Convert.ToInt32(Console.ReadLine());
Function obj3 = new Function(Leng273);
Console.WriteLine("The original sequence:");
Console.WriteLine(obj3);
obj3.ToNaturalMergeSort();
Console.WriteLine(); Console.WriteLine();
Console.WriteLine("'NaturalMergeSort' Finaly Sorting Result:");
Console.WriteLine(obj3);
break;
}
}
case 7: //基数排序
RadixSorter rS = new RadixSorter();
newIntArray = rS.RadixSort(intArray, intArray.Length);
foreach (int i in intArray)
{
Console.Write(i + " ");
}
Console.ReadKey();
break;
case 8: //计数排序
int[] intNewArray = intArray;
intNewArray = Counting.CountingSort(intArray, intArray.Length);
foreach (int i in intNewArray)
{
Console.Write(i + " ");
}
Console.ReadKey();
break;
case 9: //堆排序
HeapSort.HeapSortFunction(intArray);
foreach (int i in intArray)
{
Console.Write(i + " ");
}
Console.ReadKey();
break;
default:
Environment.Exit(0);
break;
}
}
public void ExceptionNullList3()
{
var sorter = new ShellSorter<int>();
sorter.Sort(null, SortOrder.Ascending);
}
public void ExceptionNullComparer1()
{
var sorter = new ShellSorter<int>();
sorter.Sort(new List<int>(), (IComparer<int>)null);
}
public void ExceptionNullList1()
{
var sorter = new ShellSorter<int>();
sorter.Sort(null);
}
public void ExceptionNullList2()
{
var sorter = new ShellSorter<int>();
sorter.Sort(null, Comparer<int>.Default);
}
public void Simple()
{
var sorter = new ShellSorter<int>();
TestSorter(sorter);
}
public void TestShellSorter()
{
ShellSorter <int> sorter = new ShellSorter <int>();
TestSorter(sorter);
}
public void TestShellSortNullList3()
{
ShellSorter <int> sorter = new ShellSorter <int>();
sorter.Sort(null, SortOrder.Ascending);
}
public void TestShellSortNullList2()
{
ShellSorter <int> sorter = new ShellSorter <int>();
sorter.Sort(null, Comparer <int> .Default);
}
public void TestShellSortNullList1()
{
ShellSorter <int> sorter = new ShellSorter <int>();
sorter.Sort(null);
}
