# merge sort javascript snippet in javascript

## merge sort javascript

user7107

``````// Merge Sort Implentation (Recursive)

function mergeSort (unsortedArray) {
if (unsortedArray.length <= 1) {
return unsortedArray;
}

const middle = Math.floor(unsortedArray.length / 2);

const left = unsortedArray.slice(0, middle);
const right = unsortedArray.slice(middle);

// Using recursion to combine the left and right
return merge(
mergeSort(left),
mergeSort(right)
);
}

function merge (left, right) {
let resultArray = [], leftIndex = 0, rightIndex = 0;

while (leftIndex < left.length && rightIndex < right.length) {
if (left[leftIndex] < right[rightIndex]) {
resultArray.push(left[leftIndex]);
leftIndex++;
} else {
resultArray.push(right[rightIndex]);
rightIndex++;
}
}

return resultArray
.concat(left.slice(leftIndex))
.concat(right.slice(rightIndex));
}``````

## array sorting javascript mergesort

user8868

``````// Merge Sort (Recursive)
function mergeSort (unsortedArray) {
// No need to sort the array if the array only has one element or empty
if (unsortedArray.length <= 1) {
return unsortedArray;
}
// In order to divide the array in half, we need to figure out the middle
const middle = Math.floor(unsortedArray.length / 2);

// This is where we will be dividing the array into left and right
const left = unsortedArray.slice(0, middle);
const right = unsortedArray.slice(middle);

// Using recursion to combine the left and right
return merge(
mergeSort(left), mergeSort(right)
);
}``````

## implement a merge sort algorithm JS

user7950

``````function merge(left, right) {
const resultArray = []
let leftIndex = 0
let rightIndex = 0

while (leftIndex < left.length && rightIndex < right.length) {
if (left[leftIndex] < right[rightIndex]) {
resultArray.push(left[leftIndex])
leftIndex+=1
} else {
resultArray.push(right[rightIndex])
rightIndex+=1
}
}
return resultArray
.concat(left.slice(leftIndex))
.concat(right.slice(rightIndex))
}
function mergeSort(unsortedArray) {
if (unsortedArray.length <= 1) {
return unsortedArray;
}
const middle = Math.floor(unsortedArray.length / 2);
const left = unsortedArray.slice(0, middle);
const right = unsortedArray.slice(middle);
return merge(
mergeSort(left), mergeSort(right)
);
}
mergeSort([10, 9, 8, 7, 6, 5, 4, 3, 2, 1])``````

## merge sort algorithm

user2710

``````/*
a[] is the array, p is starting index, that is 0,
and r is the last index of array.
*/

#include <stdio.h>

// lets take a[5] = {32, 45, 67, 2, 7} as the array to be sorted.

// merge sort function
void mergeSort(int a[], int p, int r)
{
int q;
if(p < r)
{
q = (p + r) / 2;
mergeSort(a, p, q);
mergeSort(a, q+1, r);
merge(a, p, q, r);
}
}

// function to merge the subarrays
void merge(int a[], int p, int q, int r)
{
int b[5];   //same size of a[]
int i, j, k;
k = 0;
i = p;
j = q + 1;
while(i <= q && j <= r)
{
if(a[i] < a[j])
{
b[k++] = a[i++];    // same as b[k]=a[i]; k++; i++;
}
else
{
b[k++] = a[j++];
}
}

while(i <= q)
{
b[k++] = a[i++];
}

while(j <= r)
{
b[k++] = a[j++];
}

for(i=r; i >= p; i--)
{
a[i] = b[--k];  // copying back the sorted list to a[]
}
}

// function to print the array
void printArray(int a[], int size)
{
int i;
for (i=0; i < size; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}

int main()
{
int arr[] = {32, 45, 67, 2, 7};
int len = sizeof(arr)/sizeof(arr[0]);

printf("Given array: \n");
printArray(arr, len);

// calling merge sort
mergeSort(arr, 0, len - 1);

printf("\nSorted array: \n");
printArray(arr, len);
return 0;
}``````

## heap sort javascript

user2438

``````var array_length;
/* to create MAX  array */
function heap_root(input, i) {
var left = 2 * i + 1;
var right = 2 * i + 2;
var max = i;

if (left < array_length && input[left] > input[max]) {
max = left;
}

if (right < array_length && input[right] > input[max])     {
max = right;
}

if (max != i) {
swap(input, i, max);
heap_root(input, max);
}
}

function swap(input, index_A, index_B) {
var temp = input[index_A];

input[index_A] = input[index_B];
input[index_B] = temp;
}

function heapSort(input) {

array_length = input.length;

for (var i = Math.floor(array_length / 2); i >= 0; i -= 1)      {
heap_root(input, i);
}

for (i = input.length - 1; i > 0; i--) {
swap(input, 0, i);
array_length--;

heap_root(input, 0);
}
}

var arr = [3, 0, 2, 5, -1, 4, 1];
heapSort(arr);
console.log(arr);

``````