Merge Sort algorithm - c++

Question

What could be the best algorithm for "Merge Sort" in C++ where the memory must be used "most effectively"? I just know the standard way to do this, but that's not the most effective way how to use the memory.
This is the only variant which I know:
#include <iostream>
using namespace std;
int main() {
int arr1[20]= {0,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
int arr2[14]= {0,23,25,27,29,31,33,35,37,39,40,41,42,43};
int arr3[34];
int indexA=0, indexB=0, indexC=0;
while((indexA<20) && (indexB<14)) {
if(arr1[indexA] < arr2[indexB]) {
arr3[indexC] = arr1[indexA];
indexA++;
}
else {
arr3[indexC] = arr2[indexB];
indexB++;
}
indexC++;
}
while(indexA<20) {
arr3[indexC] = arr1[indexA];
indexA++;
indexC++;
}
while(indexB<14) {
arr3[indexC] = arr2[indexB];
indexB++;
indexC++;
}
for (int i=0; i<34; i++)
cout << arr3[i] << " ";
return 0;
}
Can anyone please advise me a better algorithm for "Merge Sort" which uses the memory in "more effective" way? It can also not be with arrays.
Thank You very much!

Answer 1

The usual problem with merge sort is that for every recursion, you end up using a whole new piece of memory. This turns out to need O(N*log(n)) memory. It turns out that if you're a bit more clever, you can do this with linear O(N) memory. Just don't make new arrays, and swap the elements as needed around within the original one.

Answer 2

By the Algorithm nature - Merge Sort need an additional space of the Same Size of the Array you are trying to Sort.
A kind of answer to your question. The book "Data Structures & Algorithms in Java - Second Edition by Robert Lafore" has an example that used only an duplicate array of the same size instead of creating multiple sub array. You can find the program #
http://homepage.cs.uiowa.edu/~sriram/21/fall07/code/mergeSort.java
The following example is just to explain the mergesort in simple way.
import java.util.Arrays;
import java.util.Random;
public class SimpleMergeSort {
void mergeSort(int [] arr)
{
if( arr.length <= 1)
return;
int mid = arr.length / 2;
int [] left = Arrays.copyOfRange(arr, 0, mid);
int [] right = Arrays.copyOfRange(arr, mid, arr.length);
mergeSort(left);
mergeSort(right);
merge(left,right,arr);
}
void merge(int [] left, int [] right, int[] arr)
{
int arrIndex = 0;
int leftIndex = 0;
int rightIndex = 0;
//both left and right are not empty
while( leftIndex < left.length && rightIndex < right.length)
{
if( left[leftIndex] < right[rightIndex])
{
arr[arrIndex++] = left[leftIndex++];
}
else
{
arr[arrIndex++] = right[rightIndex++];
}
}
//if left still has some content
while(leftIndex < left.length)
{
arr[arrIndex++] = left[leftIndex++];
}
//if right still has some content
while(rightIndex < right.length)
{
arr[arrIndex++] = right[rightIndex++];
}
}
public static void main(String[] args) {
int [] array = new int[10];
Random random = new Random();
for(int i=0; i<array.length; i++)
{
array[i] = random.nextInt(1000);
}
System.out.println(Arrays.toString(array));
SimpleMergeSort sort = new SimpleMergeSort();
sort.mergeSort(array);
System.out.println(Arrays.toString(array));
}
}

Answer 3

instead of using merge and sorting in the main u could have used recursion which would have decreased your load in manually computing and dividing the array into two parts enter code heremid =beg+end/2;a[beg,.....,end] //so
a1[beg,...mid] //and
a2[]mid+1,....end]then call the recursion functions check the base case carefullyif(big