mergeSort

Comment

0

export function mergeSort (arr){
  if(arr.length <= 1){
    return arr;
  }
  let mid = Math.floor(arr.length /2);
  return merge(
    mergeSort (arr.slice(0,mid)),
    mergeSort (arr.slice(mid))
  )
}

function merge(left,right) {
  let mergeArr = [];
  let i = 0,j = 0;

  while(i < left.length && j < right.length) {
    if(left[i] < right[j]){
      mergeArr.push(left[i++])
    
    }else {
      mergeArr.push(right[j++])
    }
  }
  return mergeArr.concat(left.slice(i)).concat(right.slice(j));
}

Popularity 10/10 Helpfulness 1/10 Language whatever

Source: Grepper

Tags: mergesort whatever

Share

Link to this answer
Share Copy Link

Contributed on Oct 25 2022

Outrageous Octopus

0 Answers Avg Quality 2/10

merge sort

Comment

26

//merge sort
#include <iostream>

using namespace std;
void merge(int arr[],int start,int mid,int end)
{
    int n1=mid-start+1;
    int n2=end-mid;
    int l[n1],m[n2];
    for(int i=0;i<n1;i++)
    {
        l[i]=arr[start+i];
    }
    for(int j=0;j<n2;j++)
    {
        m[j]=arr[mid+1+j];
    }
    int i=0;
    int j=0;
    int k=start;
    while(i<n1&&j<n2)
    {
        if(l[i]<m[j])
        {
            arr[k]=l[i];
            k++;
            i++;
        }
        else
        {
            arr[k]=m[j];
            k++;
            j++;
        }
    }
    while(i<n1)
    {
        arr[k]=l[i];
        k++;
        i++;
    }
    while(j<n2)
    {
        arr[k]=m[j];
        k++;
        j++;
    }
}
void mergesort(int arr[],int start,int end)
{
    if(start<end)
    {
        int mid=(start+end)/2;
        mergesort(arr,start,mid);
        mergesort(arr,mid+1,end);
        merge(arr,start,mid,end);
    }
}
void display(int arr[],int n)
{
    for(int i=0;i<n;i++)
    {
        cout<<arr[i]<<" ";
    }
    cout<<endl;
}

int main()
{
    int n;
    cout<<"enter the size of the array:"<<endl;
    cin>>n;
    cout<<"enter the elements of the array:"<<endl;
    int arr[n];
    for(int i=0;i<n;i++)
    {
        cin>>arr[i];
    }
    cout<<"array as it is:"<<endl;
    display(arr,n);
    cout<<"sorted array:"<<endl;
    mergesort(arr,0,n-1);
    display(arr,n);
    return 0;
}

Popularity 10/10 Helpfulness 2/10 Language cpp

Source: Grepper

Tags: c++

Share

Link to this answer
Share Copy Link

Contributed on May 27 2021

ujjwal sotra

0 Answers Avg Quality 2/10

merge sort

Comment

1

// C#

using System;

class MergeSortAlgorithm
{
    public static void MergeSort(int[] arr)
    {
        if (arr == null || arr.Length <= 1)
            return;

        int[] temp = new int[arr.Length];
        MergeSortHelper(arr, 0, arr.Length - 1, temp);
    }

    private static void MergeSortHelper(int[] arr, int left, int right, int[] temp)
    {
        if (left < right)
        {
            int mid = left + (right - left) / 2;
            MergeSortHelper(arr, left, mid, temp);
            MergeSortHelper(arr, mid + 1, right, temp);
            Merge(arr, left, mid, right, temp);
        }
    }

    private static void Merge(int[] arr, int left, int mid, int right, int[] temp)
    {
        Array.Copy(arr, left, temp, left, right - left + 1);

        int i = left;
        int j = mid + 1;
        int k = left;

        while (i <= mid && j <= right)
        {
            if (temp[i] <= temp[j])
            {
                arr[k] = temp[i];
                i++;
            }
            else
            {
                arr[k] = temp[j];
                j++;
            }
            k++;
        }

        while (i <= mid)
        {
            arr[k] = temp[i];
            k++;
            i++;
        }
    }

    static void Main(string[] args)
    {
        int[] arr = { 12, 11, 13, 5, 6, 7 };

        Console.WriteLine("Given array is ");
        PrintArray(arr);

        MergeSort(arr);

        Console.WriteLine("\nSorted array is ");
        PrintArray(arr);
    }

    static void PrintArray(int[] arr)
    {
        foreach (var item in arr)
        {
            Console.Write(item + " ");
        }
        Console.WriteLine();
    }
}

Popularity 9/10 Helpfulness 2/10 Language cpp

Source: Grepper

Tags: algorithm algo

Share

Link to this answer
Share Copy Link

Contributed on Mar 20 2024

mrasadatik

0 Answers Avg Quality 2/10

This pseudocode describes the Merge Sort algorithm, which recursively divides the input array into smaller sub-arrays until each sub-array has only one element. Then, it merges these sub-arrays back together in sorted order. This algorithm maintains a time complexity of O(n log n) and uses additional space for the temporary arrays during merging, also O(n).

mergeSort(arr):
    if length of arr <= 1:
        return arr
    
    mid = length of arr / 2
    left = mergeSort(arr[0:mid])
    right = mergeSort(arr[mid:end])
    
    return merge(left, right)

merge(left, right):
    result = []
    while left is not empty and right is not empty:
        if first element of left <= first element of right:
            append first element of left to result
            remove first element from left
        else:
            append first element of right to result
            remove first element from right
    
    append remaining elements of left to result
    append remaining elements of right to result
    
    return result

Popularity 9/10 Helpfulness 2/10 Language whatever

Source: Grepper

Tags: merge merg

Share

Link to this answer
Share Copy Link

Contributed on Mar 20 2024

mrasadatik

0 Answers Avg Quality 2/10

merge sort

Comment

1

// Merges two subarrays of arr[].
// First subarray is arr[l..m]
// Second subarray is arr[m+1..r]
function merge(arr, l, m, r)
{
    var n1 = m - l + 1;
    var n2 = r - m;
  
    // Create temp arrays
    var L = new Array(n1); 
    var R = new Array(n2);
  
    // Copy data to temp arrays L[] and R[]
    for (var i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (var j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];
  
    // Merge the temp arrays back into arr[l..r]
  
    // Initial index of first subarray
    var i = 0;
    // Initial index of second subarray
    var j = 0;
    // Initial index of merged subarray
    var k = l;
  
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        }
        else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
  
    // Copy the remaining elements of
    // L[], if there are any
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
  
    // Copy the remaining elements of
    // R[], if there are any
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}
  
// l for left index r is
// right index of the sub-array
// of arr to be sorted
function mergeSort(arr,l, r){
    if(l>=r){
        return;//returns recursively
    }
    var m =l+ parseInt((r-l)/2);
    mergeSort(arr,l,m);
    mergeSort(arr,m+1,r);
    merge(arr,l,m,r);
}

Popularity 10/10 Helpfulness 2/10 Language javascript

Source: sorting-algorithms.me

Tags: javascript j

Share

Link to this answer
Share Copy Link

Contributed on Sep 13 2022

katanton reckless

0 Answers Avg Quality 2/10

merge sort

Comment

2

this website explains merge sort well. It also has other sorts as well.
https://computerneek.org/sortingal.html

Popularity 10/10 Helpfulness 2/10 Language whatever

Source: Grepper

Tags: merge merg

Share

Link to this answer
Share Copy Link

Contributed on Nov 26 2022

Frantic Fox

0 Answers Avg Quality 2/10

merge sort

Comment

0

#include <iostream>
#include <vector>

void merge(std::vector<int>& arr, int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;

    std::vector<int> L(n1), R(n2);

    for (int i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (int j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];

    int i = 0, j = 0, k = left;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(std::vector<int>& arr, int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;

        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);

        merge(arr, left, mid, right);
    }
}

int main() {
    std::vector<int> arr = {12, 11, 13, 5, 6, 7};
    int arr_size = arr.size();

    std::cout << "Given array is \n";
    for (int i = 0; i < arr_size; i++)
        std::cout << arr[i] << " ";
    std::cout << std::endl;

    mergeSort(arr, 0, arr_size - 1);

    std::cout << "\nSorted array is \n";
    for (int i = 0; i < arr_size; i++)
        std::cout << arr[i] << " ";
    std::cout << std::endl;

    return 0;
}

Popularity 9/10 Helpfulness 2/10 Language cpp

Source: Grepper

Tags: algorithm algo

Share

Link to this answer
Share Copy Link

Contributed on Mar 20 2024

mrasadatik

0 Answers Avg Quality 2/10

merge sort

Comment

1

<?php    
  
/* Function to merge the subarrays of a[] */  
function merge(&$a, $beg, $mid, $end)    
{    
    $n1 = ($mid - $beg) + 1;    
    $n2 = $end - $mid;    
      
   /* temporary Arrays */  
        $LeftArray = array($n1);  
        $RightArray = array($n2);  
      
    /* copy data to temp arrays */  
    for ($i = 0; $i < $n1; $i++)    
    $LeftArray[$i] = $a[$beg + $i];    
    for ($j = 0; $j < $n2; $j++)    
    $RightArray[$j] = $a[$mid + 1 + $j];    
      
    $i = 0; /* initial index of first sub-array */  
    $j = 0; /* initial index of second sub-array */   
    $k = $beg;  /* initial index of merged sub-array */  
      
    while ($i<$n1 && $j<$n2)    
    {    
        if($LeftArray[$i] <= $RightArray[$j])    
        {    
            $a[$k] = $LeftArray[$i];    
            $i++;    
        }    
        else    
        {    
            $a[$k] = $RightArray[$j];    
            $j++;    
        }    
        $k++;    
    }    
    while ($i<$n1)    
    {    
        $a[$k] = $LeftArray[$i];    
        $i++;    
        $k++;    
    }    
      
    while ($j<$n2)    
    {    
        $a[$k] = $RightArray[$j];    
        $j++;    
        $k++;    
    }    
}    
  
function mergeSort(&$a, $beg, $end)  
{  
    if ($beg < $end)   
    {  
        $mid = (int)(($beg + $end) / 2);  
        mergeSort($a, $beg, $mid);  
        mergeSort($a, $mid + 1, $end);  
        merge($a, $beg, $mid, $end);  
    }  
}  
  
/* Function to print array elements */  
    function printArray($a, $n)  
    {  
    for($i = 0; $i < $n; $i++)    
    {    
        print_r($a[$i]);    
        echo " ";    
    }        
    }  
  
    $a = array( 10, 29, 23, 6, 30, 15, 38, 40 );    
    $n = count($a);  
    echo "Before sorting array elements are - <br>";    
    printArray($a, $n);  
    mergeSort($a, 0, $n - 1);  
    echo "<br> After sorting array elements are - <br>";    
    printArray($a, $n);  
?>

Popularity 10/10 Helpfulness 2/10 Language php

Source: Grepper

Tags: merge merg

Share

Link to this answer
Share Copy Link

Contributed on Mar 16 2023

Shadow

0 Answers Avg Quality 2/10

merge sort

Comment

0

#include <stdio.h>
#include <stdlib.h>

void merge(int arr[], int left, int mid, int right) {
    int i, j, k;
    int n1 = mid - left + 1;
    int n2 = right - mid;

    // Create temporary arrays
    int* L = (int*)malloc(n1 * sizeof(int));
    int* R = (int*)malloc(n2 * sizeof(int));

    // Copy data to temporary arrays L[] and R[]
    for (i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];

    // Merge the temporary arrays back into arr[left..right]
    i = 0; // Initial index of first subarray
    j = 0; // Initial index of second subarray
    k = left; // Initial index of merged subarray
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        }
        else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    // Copy the remaining elements of L[], if there are any
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    // Copy the remaining elements of R[], if there are any
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }

    // Free temporary arrays
    free(L);
    free(R);
}

void mergeSort(int arr[], int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;

        // Sort first and second halves
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);

        // Merge the sorted halves
        merge(arr, left, mid, right);
    }
}

int main() {
    int arr[] = { 12, 11, 13, 5, 6, 7 };
    int arr_size = sizeof(arr) / sizeof(arr[0]);

    printf("Given array is \n");
    for (int i = 0; i < arr_size; i++)
        printf("%d ", arr[i]);
    printf("\n");

    mergeSort(arr, 0, arr_size - 1);

    printf("\nSorted array is \n");
    for (int i = 0; i < arr_size; i++)
        printf("%d ", arr[i]);
    printf("\n");

    return 0;
}

Popularity 8/10 Helpfulness 2/10 Language c

Source: Grepper

Tags: algorithm algo

Share

Link to this answer
Share Copy Link

Contributed on Mar 20 2024

mrasadatik

0 Answers Avg Quality 2/10

mergesort

Comment

0

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        int size = 5 ;
      double[] arrayList = new double[size];
      for(int i = 0 ; i < arrayList.length ; ++i){
          arrayList[i] = (Math.random()*1000);
      }

        mergeSort(arrayList,0,arrayList.length-1);
        print(arrayList);

    }
    public static void print(double []  arrayList){
        for(int i = 0 ; i < arrayList.length; ++i){
            System.out.println(arrayList[i]);
        }
    }
    public  static void mergeSort(double [] arr , int l , int r){
        if(l<r){
            int m = l+(r-l)/2;

            mergeSort(arr,l,m);
            mergeSort(arr,m+1,r);

            merge(arr,l , m , r);
        }

    }

    public  static void merge(double[] unsorted, int l , int m , int r){
        int i ,j ,k;
        int arr1 = m - l +1;
        int arr2 = r - m ;
        double [] left = new double[arr1];
        double [] right = new double[arr2];
        for(int f = 0 ; f < arr1 ; ++f){
            left[f] = unsorted[l+f];
        }
        for (int s = 0 ; s < arr2 ; ++s){
           right[s] = unsorted[m+1+s];
        }

        i = j = 0;
        k = l ;

        while(i < arr1 && j < arr2){
            if(left[i] <= right[j]){
                unsorted[k] = left[i];
                ++i;
            }
            else {
                unsorted[k]= right[j];
                ++j;
            }
            ++k;
        }

        while(i<arr1){
            unsorted[k] = left[i];
            ++i;++k;
        }
        while(j<arr2){
            unsorted[k] = right[j];
            ++j;++k;
        }


    }
}

Popularity 10/10 Helpfulness 2/10 Language java

Source: Grepper

Tags: java

Share

Link to this answer
Share Copy Link

Contributed on Jul 30 2021

Mero

0 Answers Avg Quality 2/10

merge sort

Comment

0

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

    const mid = Math.floor(arr.length / 2);
    const left = mergeSort(arr.slice(0, mid));
    const right = mergeSort(arr.slice(mid));

    return merge(left, right);
}

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

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

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

// Example usage:
const arr = [12, 11, 13, 5, 6, 7];
console.log("Given array is");
console.log(arr);

const sortedArr = mergeSort(arr);
console.log("\nSorted array is");
console.log(sortedArr);

Popularity 7/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: algorithm javascript jav

Share

Link to this answer
Share Copy Link

Contributed on Mar 20 2024

mrasadatik

0 Answers Avg Quality 2/10

mergeSort

Contents

More Related Answers

mergeSort

Closely Related Answers

merge sort

merge sort

merge sort

merge sort

merge sort

merge sort

merge sort

merge sort

mergesort

merge sort

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.