merge sort

Comment

0

Imagine you have a set of numbered cards, and your task is to put them in order from smallest to largest. Now, let's say there are too many cards for you to sort them all at once. Merge Sort is like having a helper who divides the cards into smaller groups, sorts each group separately, and then combines them back together in order.

Here's how Merge Sort works step by step:

1. Divide: Your helper starts by dividing the cards into smaller groups, each containing just a few cards. They continue dividing until each group only has one card. Now, a single card is already in order!

2. Sort: Next, your helper compares the cards in each pair of groups. They arrange the cards within each pair in the correct order, from smallest to largest.

3. Merge: Finally, your helper starts combining the sorted groups back together. They take two sorted groups at a time and merge them into a single, larger sorted group. They repeat this process until all the cards are back together in one big sorted stack.

By breaking the task into smaller, manageable parts and then combining them back together, Merge Sort helps you efficiently sort a large set of cards or numbers. It's like having a team of helpers working together to organize your cards neatly!

Popularity 10/10 Helpfulness 1/10 Language whatever

Source: Grepper

Tags: algorithm merge sorting whatever

Share

Link to this answer
Share Copy Link

Contributed on Mar 20 2024

mrasadatik

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

merge sort

Comment

2

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.