private void InsertSortButton_Click(object sender, EventArgs e)
{
CleaningLabels();
var insert = new InsertSort <SortedItem>(items);
BtnClick(insert);
}
private static void Sort(string[] a, int lo, int hi, int d, int R, string[] aux)
{
if (hi <= lo + M)
{
InsertSort.Sort(a, lo, hi, d); return;
}
int[] count = new int[R + 2];
// 频率计数
for (int i = lo; i <= hi; i++)
{
count[CharAt(a[i], d)]++;
}
// 计算每个字符的种类的起始索引
for (int r = 0; r < R + 1; r++)
{
count[r + 1] += count[r];
}
for (int i = 0; i <= hi; i++)
{
aux[count[CharAt(a[i], d) + 1]++] = a[i];
}
for (int i = lo; i <= hi; i++)
{
a[i] = aux[i - lo];
}
for (int r = 0; r < R; r++)
{
Sort(a, lo + count[r], lo + count[r + 1] - 1, d + 1, R, aux);
}
}
/// <summary>
/// Основное действие
/// </summary>
/// <param name="Fill">Метод заполнения массивов</param>
/// <param name="maxSize">максимальная величина массива</param>
/// <param name="message">сообщение</param>
private void ExecuteSort(Action <IArray <long>, int> Fill, int maxSize, string message)
{
Console.WriteLine($"{message} method");
IArray <long> arr1;
arr1 = new BubbleArray <long>(maxSize);
Fill(arr1, maxSize);
SortArr(arr1, "Buble sort " + message);
arr1 = new SelectedArray <long>(maxSize);
Fill(arr1, maxSize);
SortArr(arr1, "Selected sort " + message);
arr1 = new InsertSort <long>(maxSize);
Fill(arr1, maxSize);
SortArr(arr1, "Insert sort " + message);
arr1 = new MergeSort <long>(maxSize);
Fill(arr1, maxSize);
SortArr(arr1, "Merge sort " + message);
arr1 = new ShellSort <long>(maxSize);
Fill(arr1, maxSize);
SortArr(arr1, "Shell sort " + message);
arr1 = new QuickSort(maxSize);
Fill(arr1, maxSize);
SortArr(arr1, "Quick sort " + message);
Console.WriteLine();
}
private static void TrySort()
{
SortBase sort = new InsertSort();
sort.Print("-------- before insert sort ----------");
sort.DoSort();
sort.Print("-------- after insert sort ----------");
SortBase ms = new MergeSort();
ms.Print("-------- before merge sort ----------");
ms.DoSort();
ms.Print("-------- after merge sort ----------");
SortBase hs = new HeapSort();
hs.Print("-------- before heap sort ----------");
hs.DoSort();
hs.Print("-------- after heap sort ----------");
QuickSort qs = new QuickSort();
qs.Print("-------- before quick sort ----------");
qs.DoSort();
qs.Print("-------- after quick sort ----------");
CountingSort cs = new CountingSort();
cs.Print("-------- before quick sort ----------");
cs.DoSort();
cs.Print("-------- after quick sort ----------");
}
static void Main()
{
//лист пользовательских типов
IEnumerable<Person> personList = new List<Person>
{
new Person { BirthYear = 1948, Name = "Cat Stevens" },
new Person { BirthYear = 1955, Name = "Kevin Costner" },
new Person { BirthYear = 1952, Name = "Vladimir Putin" },
new Person { BirthYear = 1955, Name = "Bill Gates" },
new Person { BirthYear = 1948, Name = "Kathy Bates" },
new Person { BirthYear = 1956, Name = "David Copperfield" },
new Person { BirthYear = 1948, Name = "Jean Reno" }
};
personList = new MergeSort().Sort(personList, (x, y) => x.BirthYear.CompareTo(y.BirthYear));
//массив чисел
IEnumerable<int> intArray = new[] {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
intArray = new ShellSort().Sort(intArray, Comparer<int>.Default);
IEnumerable<KeyValuePair<string, int>> personDictionary = new Dictionary<string, int>
{
{"Cat Stevens", 1948},
{"Kevin Costner", 1955},
{"Vladimir Putin", 1952},
{"Bill Gates", 1955},
{"Kathy Bates", 1948},
{"David Copperfield", 1954},
{"Jean Reno", 1948}
};
personDictionary = new InsertSort().Sort(personDictionary, (x, y) => x.Value.CompareTo(y.Value));
}
public void TestInsertSort()
{
var sort = new InsertSort();
sort.Sort(_arr);
CollectionAssert.AreEqual(_arr, _expectedArr);
}
public void SortTest()
{
var arr = new int[] { 3, 6, 7, 4, 9 };
var insertSort = new InsertSort();
insertSort.Sort(arr, SortDirection.Desc);
}
private void InsertSort_Click(object sender, EventArgs e)
{
panel4.Controls.Clear();
var listForSort = new InsertSort <SortedItem>(items);
var NewItems = DisplayList(listForSort.Items);
listForSort = new InsertSort <SortedItem>(NewItems);
StartSorting(listForSort);
}
static void Main(string[] args)
{
ISort insertSort = new InsertSort();
var list = insertSort.Sort(new int[] { 5, 2, 4, 6, 1, 3 });
foreach (var number in list)
{
Console.Write(number + " ");
}
}
public void InsertSortTest()
{
int[] input = new int[] { 5, 4, 10, 9, 8, 3, 2, 7, 6, 1 };
InsertSort insertSort = new InsertSort();
insertSort.Sort <int>(input);
for (int i = 0; i < input.Length; i++)
{
Assert.IsTrue(input[i] == i + 1);
}
}
static void SortAlgorithm(int[] array)
{
BubbleSort.Sort(array);
Console.WriteLine($"冒泡排序结果：{string.Join(",", array)}");
QuickSort.Sort(array, 0, array.Length - 1);
Console.WriteLine($"快速排序结果：{string.Join(",", array)}");
InsertSort.Sort(array);
Console.WriteLine($"插入排序结果：{string.Join(",", array)}");
}
public void InsertSortTest()
{
var insert = new InsertSort <int>();
insert.Items.AddRange(items);
insert.Sort();
for (int i = 0; i < items.Count; i++)
{
Assert.AreEqual(sorted[i], insert.Items[i]);
}
}
public void Testing_Insertion_Sort()
{
//arrange
int[] input = new int[] { 5, 2, 9, 4 };
int[] expected = new int[] { 2, 4, 5, 9 };
//act
int[] actual = InsertSort.InsertionSort(input);
//assert
Assert.Equal(expected, actual);
}
public void Empty_Input_Throws_Error()
{
//arrange
int[] input = new int[0];
//assert
Assert.Throws <EmptyArrayException>(() =>
{
//act
var actual = InsertSort.InsertionSort(input);
});
}
//输入数字按回车进入对应的排序方法
public static void SelectASort()
{
string i = Console.ReadLine().Trim();
switch (i)
{
case "1":
{
Console.WriteLine("<*******冒泡排序法*******>");
int[] numbers = SortUtil.Read();
int[] bubblenumbers = BubbleSort.sort(numbers);
SortUtil.Write(bubblenumbers);
break;
}
case "2":
{
Console.WriteLine("<*******插入排序法*******>");
int[] numbers = SortUtil.Read();
int[] insertnumbers = InsertSort.sort(numbers);
SortUtil.Write(insertnumbers);
break;
}
case "3":
{
Console.WriteLine("<*******希尔排序法*******>");
int[] numbers = SortUtil.Read();
int[] shellnumbers = ShellSort.sort(numbers);
SortUtil.Write(shellnumbers);
break;
}
case "4":
{
Console.WriteLine("<*******简单排序法*******>");
int[] numbers = SortUtil.Read();
int[] simplenumbers = SimpleSort.sort(numbers);
SortUtil.Write(simplenumbers);
break;
}
case "5":
{
Console.WriteLine("<*******归并排序法*******>");
int[] numbers = SortUtil.Read();
int[] mergesort = MergeSort.sort(numbers);
SortUtil.Write(mergesort);
break;
}
}
}
static void testInsertSort()
{
// test InsertSort;
resetNumber();
// 开始监视代码运行时间;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
InsertSort.Sort(mNumbers);
stopwatch.Stop();
Console.WriteLine("test InsertSort=> {0}毫秒", stopwatch.Elapsed.TotalMilliseconds);
TestDebug.log(mNumbers);
}
public void SortTestInsert()
{
InsertSort <Int32> insert = new InsertSort <Int32>();
insert.Items.AddRange(list);
insert.Sort();
for (Int32 i = 0; i < sorted.Length; i++)
{
Assert.AreEqual(sorted[i], insert.Items[i]);
}
}
public void InsertSortTest()
{
int[] result = CreateResultArray();
InsertSort <int> sort = new InsertSort <int>(result);
result = sort.Sort();
for (int i = 0; i < array.Length; i++)
{
Assert.AreEqual(expected[i], result[i]);
}
}
public void SelectSortTest()
{
int[] testArray = ArrayOperations.GenerateIntegerArray(999);
int[] selectSortedArray = InsertSort.Sort(testArray);
// iterate across sorted array, verifying that it is less than or equal to the next item in the array
for (int i = 0; i < testArray.Length - 1; i++)
{
if (!(selectSortedArray[i] <= selectSortedArray[i + 1]))
{
Assert.Fail($"Array at position {i} has failed validation for Selection Sort!!!");
}
}
}
public void InsertSortTest()
{
// arrange
var insert = new InsertSort <int>();
// act
insert.Items.AddRange(Items);
insert.Sort();
// assert
for (int i = 0; i < insert.Items.Count; i++)
{
Assert.AreEqual(Sorted[i], insert.Items[i]);
}
}
static void template()
{
int[] nums = { 243, 5, 7, 22, 3, 11 };
long paytime = 0;
//SortBase sort=new BetterQuickSort1();
//SortBase sort=new QuickSort();
//SortBase sort=new BubblingSort();
//SortBase sort=new SelectSort();
SortBase sort = new InsertSort();
paytime = sort.run(nums);
Console.WriteLine("paytime=" + paytime);
}
static void Main(string[] args)
{
int[] grandezza = { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 30000, 50000, 100000, 150000, 200000, };
using (StreamWriter sw = new StreamWriter("file.csv", false, Encoding.UTF8))
{
sw.WriteLine("Algoritmo;Dimensione;Tempo");
foreach (int dim in grandezza)
{
Console.WriteLine(dim);
int[] array = new int[dim];
Random r = new Random();
for (int x = 0; x < dim; x++)
{
array[x] = r.Next(0, 100);
}
Stopwatch s = new Stopwatch();
s.Restart();
BubbleSort.sort(Copia(array));
s.Stop();
long temp = s.ElapsedMilliseconds;
sw.WriteLine($"BubbleSort;{dim};{temp}");
s.Restart();
InsertSort.Sort(Copia(array));
s.Stop();
temp = s.ElapsedMilliseconds;
sw.WriteLine($"InsertionSort;{dim};{temp}");
s.Restart();
InsertSort.Sort(Copia(array));
s.Stop();
temp = s.ElapsedMilliseconds;
sw.WriteLine($"SelectionSort;{dim};{temp}");
s.Restart();
Array.Sort(Copia(array));
s.Stop();
temp = s.ElapsedMilliseconds;
sw.WriteLine($"ArraySort;{dim};{temp}");
s.Restart();
MergeSort.Sort(Copia(array));
s.Stop();
temp = s.ElapsedMilliseconds;
sw.WriteLine($"MergeSort;{dim};{temp}");
}
sw.Flush();
}
}
private void InsertSortButtonClick(object sender, EventArgs e)
{
if (progressBarCount < 2)
{
MessageBox.Show("нечего сортировать");
}
else
{
var insert = new InsertSort <int>();
insert.Items.AddRange(values.Select(x => x.Bar.Value));
insert.SwapEvent += SwapEvent;
var time = insert.Sort();
ShowInfoAboutSort(insert, time);
}
}
static void PerformCountSort(int sizeArray)
{
SortingAlgorithms sorting = new InsertSort(sizeArray);
sorting.FillArray();
Stopwatch watch = new Stopwatch();
watch.Start();
sorting.SortArray();
watch.Stop();
var arr = sorting.GetSortedArray;
Print(arr);
Console.WriteLine($"Total Execution Time: {watch.ElapsedMilliseconds} ms");
}
static void Main(string[] args)
{
var list = new IComparable[] { 1, 10, 6, 13, 4, 3, 2, 1, 1, 6, 5, 3, 7, 4, 1 }.ToList();
InsertSort insAlg = new InsertSort();
Console.WriteLine(insAlg.Sort(list).Render());
Console.ReadKey();
list = new IComparable[] { 1, 15, 56, 0, -2, 4, 2, 7, 4, 7, 34, 1, 23, 2, 6, 4, 1, 12 }.ToList();
MergeSort mergeAlg = new MergeSort();
System.IO.File.WriteAllText
(@"C:\temp\growth.dat", mergeAlg.Growth(20000, 100).Render());
Console.ReadKey();
Console.ReadKey();
}
static void Main(string[] args)
{
double[] d = { 2, 3, 1, 9, 8, 4, 10 };
List <double> listd = new List <double>();
foreach (double j in d)
{
listd.Add(j);
}
sortMethod sortTest = new InsertSort();
sortTest.sort(ref listd);
foreach (double num in listd)
{
Console.WriteLine(num);
}
Console.ReadKey();
}
public void SortTest()
{
//arrenge
var insert = new InsertSort <int>();
var rnd = new Random();
var items = new List <int>();
for (int i = 0; i < 15; i++)
{
items.Add(rnd.Next(0, 100));
}
insert.Items.AddRange(items);
var sorted = items.OrderBy(x => x).ToArray();//стадартная сортировка List
//act
insert.Sort();
//assert
for (int i = 0; i < items.Count; i++)
{
Assert.AreEqual(sorted[i], insert.Items[i]);
}
}
public void test_sorted_with_change_couple()
{
int[] array = { 1, 2, 3, 5, 4, 6, 7 };
InsertSort.insert_sort(array);
CollectionAssert.AreEqual(result_array, array);
}
public void test_sorted_with_change_firstlast()
{
int[] array = { 7, 2, 3, 4, 5, 6, 1 };
InsertSort.insert_sort(array);
CollectionAssert.AreEqual(result_array, array);
}
public void test_random()
{
int[] array = { 3, 5, 1, 4, 7, 2, 6 };
InsertSort.insert_sort(array);
CollectionAssert.AreEqual(result_array, array);
}
public void test_sorted_reverse()
{
int[] array = { 7, 6, 5, 4, 3, 2, 1 };
InsertSort.insert_sort(array);
CollectionAssert.AreEqual(result_array, array);
}
