insertion-sort

This is a question from Introduction to Algorithms By Cormen. But this isn't a homework problem instead self-study. There is an array of length n . Consider a modification to merge sort in which n/k sublists each of length k are sorted using insertion sort and then merged using merging mechanism, where k is a value to be determined. The relationship between n and k isn't known. The length of array is n . k sublists of n/k means n * (n/k) equals n elements of the array. Hence k is simply a limit at which the splitting of array for use with merge-sort is stopped and instead insertion-sort is

I have an array of 100 elements that needs to be sorted with insertion sort using OpenMP. When I parallelize my sort it does not give correct values. Can some one help me void insertionSort(int a[]) { int i, j, k; #pragma omp parallel for private(i) for(i = 0; i < 100; i++) { k = a[i]; for (j = i; j > 0 && a[j-1] > k; j--) #pragma omp critical a[j] = a[j-1]; a[j] = k; } } Variables "j" and "k" need to be private on the parallel region. Otherwise you have a data race condition. Alexey Kukanov Unless it's a homework, sorting as few as 100 elements in parallel makes no sense: the overhead

I'm trying out Scala and I want to see how one would implement insertion sort in scala with the following requirements: Nested for loops Array[Int] for input If possible a way to modify the contents of the function in a call by reference way otherwise return an Array[Int] If this isn't the Scala way of implementing insertion sort can you still provide code for the above and explain what is wrong with the approach. edit: This is an attempt using a while loop (doest work) and no it isn't a homework question, why the hostility? def insert_sort(a:Array[Int]):Array[Int]={ for(i <- 0 until a.length)

Good day SO community, I am a CS student currently performing an experiment combining MergeSort and InsertionSort. It is understood that for a certain threshold, S, InsertionSort will have a quicker execution time than MergeSort. Hence, by merging both sorting algorithms, the total runtime will be optimized. However, after running the experiment many times, using a sample size of 1000, and varying sizes of S, the results of the experiment does not give a definitive answer each time. Here is a picture of the better results obtained (Note that half of the time the result is not as definitive):

I don't understand: why is my insertion sort implementation beating merge sort every time, for any size of n ? public List<Int32> InsertionSort(List<Int32> elements, Boolean ascending = true) { for (Int32 j = 1; j < elements.Count; j++) { Int32 key = elements[j]; Int32 i = j - 1; while (i >= 0 && (elements[i].CompareTo(key) > 0) == ascending) elements[i + 1] = elements[i--]; elements[i + 1] = key; } return elements; } public List<Int32> MergeSort(List<Int32> elements, Boolean ascending = true) { Sort(elements, 0, elements.Count - 1); return elements; } private void MergeSort(List<Int32>