Merge sort in cpp

Competitive Coding/Sorting/Merge_Sort/Merge_Sort.c

@@ -1,65 +1,85 @@
-/* Merge sort in C */
-#include<stdio.h>
-#include<stdlib.h>
-
-// Function to Merge Arrays L and R into A. 
-// lefCount = number of elements in L
-// rightCount = number of elements in R. 
-void Merge(int *A,int *L,int leftCount,int *R,int rightCount) {
-	int i,j,k;
-
-	// i - to mark the index of left aubarray (L)
-	// j - to mark the index of right sub-raay (R)
-	// k - to mark the index of merged subarray (A)
-	i = 0; j = 0; k =0;
-
-	while(i<leftCount && j< rightCount) {
-		if(L[i]  < R[j]) A[k++] = L[i++];
-		else A[k++] = R[j++];
-	}
-	while(i < leftCount) A[k++] = L[i++];
-	while(j < rightCount) A[k++] = R[j++];
+/* Merge sort in Cpp */
+#include < iostream >
+  using namespace std;
+
+void merge(int arr[], int l, int m, int r) {
+  int i = l;
+  int j = m + 1;
+  int k = l;
+
+  /* create temp array */
+  int temp[5];
+
+  while (i <= m && j <= r) {
+    if (arr[i] <= arr[j]) {
+      temp[k] = arr[i];
+      i++;
+      k++;
+    } else {
+      temp[k] = arr[j];
+      j++;
+      k++;
+    }
+
+  }
+
+  /* Copy the remaining elements of first half, if there are any */
+  while (i <= m) {
+    temp[k] = arr[i];
+    i++;
+    k++;
+
+  }
+
+  /* Copy the remaining elements of second half, if there are any */
+  while (j <= r) {
+    temp[k] = arr[j];
+    j++;
+    k++;
+  }
+
+  /* Copy the temp array to original array */
+  for (int p = l; p <= r; p++) {
+    arr[p] = temp[p];
+  }
 }
-
-// Recursive function to sort an array of integers. 
-void MergeSort(int *A,int n) {
-	int mid,i, *L, *R;
-	if(n < 2) return; // base condition. If the array has less than two element, do nothing. 
-
-	mid = n/2;  // find the mid index. 
-
-	// create left and right subarrays
-	// mid elements (from index 0 till mid-1) should be part of left sub-array 
-	// and (n-mid) elements (from mid to n-1) will be part of right sub-array
-	L = (int*)malloc(mid*sizeof(int)); 
-	R = (int*)malloc((n- mid)*sizeof(int)); 
-
-	for(i = 0;i<mid;i++) L[i] = A[i]; // creating left subarray
-	for(i = mid;i<n;i++) R[i-mid] = A[i]; // creating right subarray
-
-	MergeSort(L,mid);  // sorting the left subarray
-	MergeSort(R,n-mid);  // sorting the right subarray
-	Merge(A,L,mid,R,n-mid);  // Merging L and R into A as sorted list.
-        free(L);
-        free(R);
+
+/* l is for left index and r is right index of the 
+   sub-array of arr to be sorted */
+void mergeSort(int arr[], int l, int r) {
+  if (l < r) {
+    // find midpoint
+    int m = (l + r) / 2;
+
+    // recurcive mergesort first and second halves 
+    mergeSort(arr, l, m);
+    mergeSort(arr, m + 1, r);
+
+    // merge
+    merge(arr, l, m, r);
+  }
 }
-
+ 
 int main() {
-	/* Code to test the MergeSort function. */
-
-	int A[] = {6,2,3,1,9,10,15,13,12,17}; // creating an array of integers. 
-	int i,numberOfElements;
-
-	// finding number of elements in array as size of complete array in bytes divided by size of integer in bytes. 
-	// This won't work if array is passed to the function because array
-	// is always passed by reference through a pointer. So sizeOf function will give size of pointer and not the array.
-	// Watch this video to understand this concept - http://www.youtube.com/watch?v=CpjVucvAc3g  
-	numberOfElements = sizeof(A)/sizeof(A[0]); 
-
-	// Calling merge sort to sort the array. 
-	MergeSort(A,numberOfElements);
-
-	//printing all elements in the array once its sorted.
-	for(i = 0;i < numberOfElements;i++) printf("%d ",A[i]);
-	return 0;
+  int myarray[5];
+  //int arr_size = sizeof(myarray)/sizeof(myarray[0]);
+  int arr_size = 5;
+
+  cout << "Enter 5 integers in any order: " << endl;
+  for (int i = 0; i < 5; i++) {
+    cin >> myarray[i];
+  }
+  cout << "Before Sorting" << endl;
+  for (int i = 0; i < 5; i++) {
+    cout << myarray[i] << " ";
+  }
+  cout << endl;
+  mergeSort(myarray, 0, (arr_size - 1)); // mergesort(arr,left,right) called
+
+  cout << "After Sorting" << endl;
+  for (int i = 0; i < 5; i++) {
+    cout << myarray[i] << " ";
+  }
+
+  return 0;
 }