Merge Sort

Comment

0

def mergeSort(arr):
        if len(arr) > 1:
 
            # Create sub_array2 ← A[start..mid] and sub_array2 ← A[mid+1..end]
            mid = len(arr)//2
            sub_array1 = arr[:mid]
            sub_array2 = arr[mid:]
 
            # Sort the two halves
            mergeSort(sub_array1)
            mergeSort(sub_array2)
         
            # Initial values for pointers that we use to keep track of where we are in each array
            i = j = k = 0
 
        # Until we reach the end of either start or end, pick larger among
        # elements start and end and place them in the correct position in the sorted array
            while i < len(sub_array1) and j < len(sub_array2):
                if sub_array1[i] < sub_array2[j]:
                    arr[k] = sub_array1[i]
                    i += 1
                else:
                    arr[k] = sub_array2[j]
                    j += 1
                k += 1
 
        # When all elements are traversed in either arr1 or arr2,
        # pick up the remaining elements and put in sorted array
            while i < len(sub_array1):
                arr[k] = sub_array1[i]
                i += 1
                k += 1
 
            while j < len(sub_array2):
                arr[k] = sub_array2[j]
                j += 1
                k += 1
 
    arr = [10, 9, 2, 4, 6, 13]
    mergeSort(arr)
    print(arr)

Popularity 9/10 Helpfulness 1/10 Language whatever

Source: www.scaler.com

Tags: merge whatever

Share

Link to this answer
Share Copy Link

Contributed on Jan 30 2023

Obnoxious Oyster

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 10/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

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 8/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: algorithm javascript j

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

merge sort

Comment

0

def mergeSort(arr):
    if len(arr) > 1:
  
         # Finding the mid of the array
        mid = len(arr)//2
  
        # Dividing the array elements
        L = arr[:mid]
  
        # into 2 halves
        R = arr[mid:]
  
        # Sorting the first half
        mergeSort(L)
  
        # Sorting the second half
        mergeSort(R)
  
        i = j = k = 0
  
        # Copy data to temp arrays L[] and R[]
        while i < len(L) and j < len(R):
            if L[i] < R[j]:
                arr[k] = L[i]
                i += 1
            else:
                arr[k] = R[j]
                j += 1
            k += 1
  
        # Checking if any element was left
        while i < len(L):
            arr[k] = L[i]
            i += 1
            k += 1
  
        while j < len(R):
            arr[k] = R[j]
            j += 1
            k += 1

Popularity 10/10 Helpfulness 2/10 Language whatever

Source: Grepper

Tags: merge merg

Share

Link to this answer
Share Copy Link

Contributed on Feb 17 2022

Defiant Donkey

0 Answers Avg Quality 2/10

Merge Sort

Contents

More Related Answers

Merge Sort

Closely Related Answers

merge sort

merge sort

merge sort

merge sort

merge sort

merge sort

merge sort

merge sort

merge sort

merge sort

Grepper

Documentation

Social

Legal

Contact

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