public void SortingTest()
{
Action <int[]>[] actions = new Action <int[]>[]
{
BubbleSort.Sort,
data => BucketSort.Sort(data, SortingTests.MaxValue),
data => CountingSort.Sort(data, SortingTests.MaxValue),
HeapSort.Sort,
InsertionSort.Sort,
MergeSort.Sort,
QuickSort.Sort,
data => RadixSort.Sort(data, SortingTests.MaxValue),
};
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 100; j++)
{
int[] data = ArrayUtilities.CreateRandomArray(j, 0, SortingTests.MaxValue);
int[][] results = new int[actions.Length][];
for (int k = 0; k < actions.Length; k++)
{
results[k] = new int[data.Length];
Array.Copy(data, results[k], data.Length);
actions[k](results[k]);
Assert.IsTrue(ArrayUtilities.AreEqual(results[k], results[0]));
}
}
}
}
public void TestSort()
{
var arr = new[] { 3, 41, 52, 26, 38, 57, 9, 49 };
BucketSort.Sort(arr);
Assert.IsTrue(arr.SequenceEqual(new[] { 3, 9, 26, 38, 41, 49, 52, 57 }));
}
public BucketSortTests()
{
var sort = new BucketSort <int>();
func = array => sort.Sort(array);
this.sort = sort;
algorithm = nameof(BucketSort <int>);
}
public void BucketSort_Smoke_Test()
{
var result = BucketSort.Sort(TestArray, 4);
for (int i = 0; i < TestArray.Length; i++)
{
Assert.AreEqual(i, result[i]);
}
}
public void Test_BucketSort()
{
int[] arr = new int[] { -1, 25, -58964, 8547, -119, 0, 78596 };
var result = sort.Sort(arr, arr.Length - 1);
int[] expectedAsc = { -58964, -119, -1, 0, 25, 8547, 78596 };
Assert.Equal(expectedAsc, result);
}
public void BucketSort_Descending_Smoke_Test()
{
var result = BucketSort.Sort(testArray, 11, SortDirection.Descending);
for (int i = 0; i < testArray.Length; i++)
{
Assert.AreEqual(testArray.Length - i - 1, result[i]);
}
}
public void BucketSort_Ascending_Smoke_Test()
{
var result = BucketSort.Sort(testArray, 11);
for (int i = 0; i < testArray.Length; i++)
{
Assert.AreEqual(i, result[i]);
}
}
public void Sort()
{
float[] arr = new float[] { 0.897F, 0.565F, 0.656F, 0.1234F, 0.665F, 0.3434F };
float[] resultArr = new float[] { 0.1234F, 0.3434F, 0.565F, 0.656F, 0.665F, 0.897F };
BucketSort bucketSort = new BucketSort();
bucketSort.Sort(arr);
Assert.Equal(resultArr, arr);
}
public void SortWithEmptyArray()
{
float[] arr = new float[] {};
float[] resultArr = new float[] {};
BucketSort bucketSort = new BucketSort();
bucketSort.Sort(arr);
Assert.Equal(resultArr, arr);
}
public static void Main()
{
var elements = Console.ReadLine()
.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
.Select(int.Parse)
.ToArray();
BucketSort.Sort(elements, elements.Length);
Console.WriteLine(string.Join(" ", elements));
}
public void BucketSortTest()
{
for (int i = 0; i < 100; i++)
{
int[] originData = Util.GenRandomIntArr();
int[] sortedData = (int[])originData.Clone();
Array.Sort(sortedData);
BucketSort.Sort(originData);
Assert.IsTrue(Util.CompareList(originData, sortedData));
}
}
public void ArraySorted([Random(0, 1000, 100, Distinct = true)] int n)
{
// Arrange
var sorter = new BucketSort();
var intComparer = new IntComparer();
var(correctArray, testArray) = RandomHelper.GetArrays(n);
// Act
sorter.Sort(testArray, intComparer);
Array.Sort(correctArray);
// Assert
Assert.AreEqual(correctArray, testArray);
}
public void BucketSort_Stress_Test()
{
var rnd = new Random();
var nodeCount = 1000 * 1000;
var randomNumbers = Enumerable.Range(1, nodeCount)
.OrderBy(x => rnd.Next())
.ToList();
var result = BucketSort.Sort(randomNumbers.ToArray(), 11);
for (int i = 1; i <= nodeCount; i++)
{
Assert.AreEqual(i, result[i - 1]);
}
}
public void Test(float[] data)
{
// Arrange
var data2 = new float[data.Length];
Array.Copy(data, data2, data.Length);
Array.Sort(data2);
var sorter = new BucketSort();
// Act
sorter.Sort(data);
// Assert
CollectionAssert.AreEqual(data, data2);
}
public void BucketSort_Descending_Stress_Test()
{
var rnd = new Random();
var nodeCount = 1000;
var randomNumbers = Enumerable.Range(1, nodeCount)
.OrderBy(x => rnd.Next())
.ToList();
var result = BucketSort.Sort(randomNumbers.ToArray(), 4, SortDirection.Descending);
for (int i = 0; i < nodeCount; i++)
{
Assert.AreEqual(randomNumbers.Count - i, result[i]);
}
}
public void SortTest()
{
List <int> items = new List <int> {
1, 5, 3, 9, 5, 6, 8, 7, 2, 8
};
List <int> expectedItems = new List <int> {
1, 2, 3, 5, 5, 6, 7, 8, 8, 9
};
int numBuckets = 10;
items = (List <int>)BucketSort.Sort(items, numBuckets);
CollectionAssert.AreEqual(expectedItems, items);
}
/// <summary>
/// Checks if a given graph is planar and provides a planar embedding if so.
/// </summary>
/// <param name="graph">Graph</param>
/// <param name="embedding">Planar embedding if a given graph is planar, null otherwise</param>
/// <returns>True if planar, false otherwise</returns>
public bool IsPlanar(IGraph <T> graph, out PlanarEmbedding <T> embedding)
{
// Transforms input graph
TransformGraph(graph);
// Init helper collections
selfLoopsNew = new List <IEdge <Vertex <T> > >();
mergeStackNew = new Stack <MergeInfo>();
// Use DFS traversal to add basic information to each of the vertices
var visitor = new DFSTraversalVisitor <T>();
DFSTraversal.Traverse(transformedGraph, visitor);
// Sort vertices by dfs number ASC
verticesByDFSNumberNew = BucketSort.Sort(transformedGraph.Vertices, x => x.DFSNumber, transformedGraph.VerticesCount);
// Sort vertices by low point ASC
verticesByLowPointNew = BucketSort.Sort(transformedGraph.Vertices, x => x.LowPoint, transformedGraph.VerticesCount);
// Init vertex fields
foreach (var vertex in transformedGraph.Vertices)
{
vertex.BackEdges = new List <IEdge <Vertex <T> > >();
vertex.Visited = int.MaxValue;
vertex.BackedgeFlag = transformedGraph.VerticesCount + 1;
vertex.Flipped = false;
var dfsParent = vertex.Parent;
if (vertex != dfsParent)
{
var parentEdge = vertex.DFSEdge;
vertex.FaceHandle = new FaceHandle <Vertex <T> >(vertex, parentEdge);
vertex.DFSChildHandle = new FaceHandle <Vertex <T> >(dfsParent, parentEdge);
}
else
{
vertex.FaceHandle = new FaceHandle <Vertex <T> >(vertex, (Vertex <T>)null); // TODO: change
vertex.DFSChildHandle = new FaceHandle <Vertex <T> >(dfsParent, (Vertex <T>)null);
}
vertex.CanonicalDFSChild = vertex;
vertex.PertinentRoots = new LinkedList <FaceHandle <Vertex <T> > >();
vertex.SeparatedDFSChildList = new LinkedList <Vertex <T> >();
}
// Init separated dfs child lists
//
// Original Boost comment:
// We need to create a list of not-yet-merged depth-first children for
// each vertex that will be updated as bicomps get merged. We sort each
// list by ascending lowpoint, which allows the externally_active
// function to run in constant time, and we keep a pointer to each
// vertex's representation in its parent's list, which allows merging
//in constant time.
foreach (var vertex in verticesByLowPointNew)
{
var dfsParent = vertex.Parent;
if (vertex != dfsParent)
{
var node = dfsParent.SeparatedDFSChildList.AddLast(vertex);
vertex.SeparatedNodeInParentList = node;
}
}
// Call the main algorithm
var isPlanar = IsPlanar();
if (!isPlanar)
{
embedding = null;
return(false);
}
embedding = GetPlanarEmbedding();
return(true);
}
public void Run(IInputSample <int>[] items)
{
foreach (var item in items)
{
if (item.Samples != null)
{
Init(item.Samples);
// -- Exchange -- //
// Bubble Sort
RunSort(new BubbleSort <int>(), item);
// OddEven Sort
RunSort(new OddEvenSort <int>(), item);
// Cocktail Shaker Sort
RunSort(new CocktailShakerSort <int>(), item);
RunSort(new CocktailShakerSort2 <int>(), item);
// Comb Sort
RunSort(new CombSort <int>(), item);
// Cycle Sort
RunSort(new CycleSort <int>(), item);
// Stooge Sort
RunSort(new StoogeSort <int>(), item);
// Too slow....
if (item.Samples.Length < 100)
{
// Bogo Sort
RunSort(new BogoSort <int>(), item);
}
if (item.Samples.Length < 1000)
{
// Slow Sort
RunSort(new SlowSort <int>(), item);
}
// Gnome Sort
RunSort(new GnomeSort <int>(), item);
RunSort(new GnomeSort1 <int>(), item);
RunSort(new GnomeSort2 <int>(), item);
RunSort(new GnomeSort3 <int>(), item);
// -- Selection -- //
// Selection Sort
RunSort(new SelectionSort <int>(), item);
// Heap Sort
RunSort(new HeapSort <int>(), item);
// Smooth Sort
RunSort(new SmoothSort <int>(), item);
// -- Insertion -- //
// Insert Sort
RunSort(new InsertSort <int>(), item);
// Binary Insert Sort
RunSort(new BinaryInsertSort <int>(), item);
// Shell Sort
RunSort(new ShellSort <int>(), item);
// Binary Tree Sort
RunSort(new BinaryTreeSort <int>(), item);
// -- Partitionig -- //
// Quick Sort Median3
RunSort(new QuickSortMedian3 <int>(), item);
// Quick Sort Median9
RunSort(new QuickSortMedian9 <int>(), item);
// Dual Pivot QuickSort
RunSort(new QuickDualPivotSort <int>(), item);
// QuickSort Median3 (Quick + Insert)
RunSort(new QuickSortMedian3Insert <int>(), item);
// QuickSort Median9 (Quick + Insert)
RunSort(new QuickSortMedian9Insert <int>(), item);
// Dual Pivot Quick Sort (Quick + Insert)
RunSort(new QuickDualPivotSortInsert <int>(), item);
// QuickSort Median3 (Quick + BinaryInsert)
RunSort(new QuickSortMedian3BinaryInsert <int>(), item);
// QuickSort Median9 (Quick + BinaryInsert)
RunSort(new QuickSortMedian9BinaryInsert <int>(), item);
// Dual Pivot Quick Sort (Quick + BinaryInsert)
RunSort(new QuickDualPivotSortBinaryInsert <int>(), item);
// -- Merge -- //
// Merge Sort
RunSort(new MergeSort <int>(), item);
RunSort(new MergeSort2 <int>(), item);
// Shift Sort
RunSort(new ShiftSort <int>(), item);
// DropMerge Sort
RunSort(new DropMergeSort <int>(), item);
// -- Distribution -- //
// Bucket Sort
var bucketSort = new BucketSort <int>();
RunSort(bucketSort, array => bucketSort.Sort(array), item);
// Radix Sort(LSD)
var radix10Sort = new RadixLSD10Sort <int>();
RunSort(radix10Sort, array => radix10Sort.Sort(array), item);
var radix4Sort = new RadixLSD4Sort <int>();
RunSort(radix4Sort, array => radix4Sort.Sort(array), item);
// Counting Sort
var countingSort = new CountingSort <int>();
RunSort(countingSort, array => countingSort.Sort(array), item);
// -- Hybrid -- //
// IntroSort Median3 (Quick + Heap + Insert)
//RunSort(new IntroSortMedian3<int>(), item);
// IntroSort Median9 (Quick + Heap + Insert)
RunSort(new IntroSortMedian9 <int>(), item);
// IntroSort Median9 (Insert + Merge)
//RunSort(new TimSort<int>(), item);
// -- Other -- //
// Pancake Sort
RunSort(new PancakeSort <int>(), item);
}
// BucketSort<T>
if (item.Samples == null && item.DictionarySamples != null)
{
Init(item.DictionarySamples);
// -- Distribution -- //
RunBucketTSort(new BucketSortT <KeyValuePair <int, string> >(), x => x.Key, item.DictionarySamples.Max(x => x.Key), item);
}
}
}