Skip to content
Related Articles

Related Articles

Shell-Metzner Sort

View Discussion
Improve Article
Save Article
  • Last Updated : 31 May, 2021

Given an array arr[] of N integers, the task is to sort the array using Shell-Metzner sort.
 

Input: arr[] = {0, -2, 8, 5, 1} 
Output: -2 0 1 5 8
Input: arr[] = {4, 5, 6, 1, 100000, 1000} 
Output: 1 4 5 6 1000 100000 
 

 

Prerequisite: Shell Sort
The Shell-Metzner sort is an adaptation of the Shell sort by Marlene Metzner. The Shell-Metzner Sort uses five indices to check which cells to swap. The Metzner version starts with a step size equal to half the length of the array, with each pass increasing the number of comparisons quadratically.
Below is the implementation of Shell-Metzner sort: 
 

C++




// C++ implementation of Shell-Metzner Sort
#include <bits/stdc++.h>
using namespace std;
 
// Function to swap two elements
void swap(int& a, int& b)
{
    int temp = a;
    a = b;
    b = temp;
}
 
// Function to sort arr[] using Shell Metzner sort
void sort_shell_metzner(int arr[], int n)
{
 
    // Declare variables
    int i, j, k, l, m, temp;
 
    // Set initial step size to
    // the size of the array
    m = n;
 
    while (m > 0) {
 
        // Step size decreases by half each time
        m /= 2;
 
        // k is the upper limit for j
        k = n - m;
 
        // j is the starting point
        j = 0;
 
        do {
 
            // i equals to smaller value
            i = j;
 
            do {
 
                // l equals to larger value
                l = i + m;
 
                // Compare and swap arr[i] with arr[l]
                if (arr[i] > arr[l]) {
                    swap(arr[i], arr[l]);
 
                    // Decrease smaller value by step size
                    i -= m;
                }
                else
                    break;
            } while (i >= 0);
 
            // Increment the lower limit of i
            j++;
 
        } while (j <= k);
    }
}
 
// Function to print the contents of an array
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}
 
// Driver code
int main()
{
    int arr[] = { 0, -2, 8, 5, 1 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Sort the array using Shell Metzner Sort
    sort_shell_metzner(arr, n);
 
    // Print the sorted array
    printArray(arr, n);
 
    return 0;
}


Java




// Java implementation of Shell-Metzner Sort
class GFG
{
 
    // Function to swap two elements
    static int[] swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        return arr;
    }
     
    // Function to sort arr[] using Shell Metzner sort
    static void sort_shell_metzner(int arr[], int n)
    {
 
        // Declare variables
        int i, j, k, l, m, temp;
 
        // Set initial step size to
        // the size of the array
        m = n;
 
        while (m > 0)
        {
 
            // Step size decreases by half each time
            m /= 2;
 
            // k is the upper limit for j
            k = n - m;
 
            // j is the starting point
            j = 0;
 
            do
            {
 
                // i equals to smaller value
                i = j;
 
                do
                {
 
                    // l equals to larger value
                    l = i + m;
 
                    // Compare and swap arr[i] with arr[l]
                    if (l < n && arr[i] > arr[l])
                    {
                        swap(arr, i, l);
 
                        // Decrease smaller value by step size
                        i -= m;
                    }
                    else
                    {
                        break;
                    }
                } while (i >= 0);
 
                // Increment the lower limit of i
                j++;
 
            } while (j <= k);
        }
    }
 
    // Function to print the contents of an array
    static void printArray(int arr[], int n)
    {
        for (int i = 0; i < n; i++)
        {
            System.out.print(arr[i] + " ");
        }
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = {0, -2, 8, 5, 1};
        int n = arr.length;
 
        // Sort the array using Shell Metzner Sort
        sort_shell_metzner(arr, n);
 
        // Print the sorted array
        printArray(arr, n);
    }
}
 
/* This code contributed by PrinciRaj1992 */


Python3




# Python3 implementation of Shell-Metzner Sort
 
# Function to sort arr[] using Shell Metzner sort
def sort_shell_metzner( arr, n):
 
    # Set initial step size to
    # the size of the array
    m = n;
 
    while (m > 0):
 
        # Step size decreases by half each time
        m //= 2
 
        # k is the upper limit for j
        k = n - m
 
        # j is the starting point
        j = 0
 
        while(j < k):
 
            # i equals to smaller value
            i = j
 
            while(i >= 0):
 
                # l equals to larger value
                l = i + m
 
                # Compare and swap arr[i] with arr[l]
                if (arr[i] > arr[l]):
                    arr[i], arr[l]=arr[l],arr[i]
 
                    # Decrease smaller value by step size
                    i -= m
         
                else:
                    break
 
            # Increment the lower limit of i
            j += 1
 
# Function to print the contents of an array
def printArray(arr, n):
 
    for i in range( n):
        print( arr[i], end= " ")
 
# Driver code
if __name__ =="__main__":
    arr = [ 0, -2, 8, 5, 1 ]
    n = len(arr)
 
    # Sort the array using Shell Metzner Sort
    sort_shell_metzner(arr, n)
 
    # Print the sorted array
    printArray(arr, n)
 
# This code is contributed by chitranayal


C#




// C# implementation of Shell-Metzner Sort
using System;
 
class GFG
{
 
    // Function to swap two elements
    static int[] swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        return arr;
    }
     
    // Function to sort arr[] using Shell Metzner sort
    static void sort_shell_metzner(int []arr, int n)
    {
 
        // Declare variables
        int i, j, k, l, m, temp;
 
        // Set initial step size to
        // the size of the array
        m = n;
 
        while (m > 0)
        {
 
            // Step size decreases by half each time
            m /= 2;
 
            // k is the upper limit for j
            k = n - m;
 
            // j is the starting point
            j = 0;
 
            do
            {
 
                // i equals to smaller value
                i = j;
 
                do
                {
 
                    // l equals to larger value
                    l = i + m;
 
                    // Compare and swap arr[i] with arr[l]
                    if (l < n && arr[i] > arr[l])
                    {
                        swap(arr, i, l);
 
                        // Decrease smaller value by step size
                        i -= m;
                    }
                    else
                    {
                        break;
                    }
                } while (i >= 0);
 
                // Increment the lower limit of i
                j++;
 
            } while (j <= k);
        }
    }
 
    // Function to print the contents of an array
    static void printArray(int []arr, int n)
    {
        for (int i = 0; i < n; i++)
        {
            Console.Write(arr[i] + " ");
        }
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int []arr = {0, -2, 8, 5, 1};
        int n = arr.Length;
 
        // Sort the array using Shell Metzner Sort
        sort_shell_metzner(arr, n);
 
        // Print the sorted array
        printArray(arr, n);
    }
}
 
// This code has been contributed by 29AjayKumar


PHP




<?php
// php implementation of Shell-Metzner Sort
 
// Function to sort arr[] using Shell Metzner sort
function sort_shell_metzner($arr, $n)
{
    // Set initial step size to
    // the size of the array
    $m = $n;
 
    while ($m > 0)
    {
 
        // Step size decreases by half each time
        $m = $m / 2;
 
        // k is the upper limit for j
        $k = $n - $m;
 
        // j is the starting point
        $j = 0;
 
        do {
 
            // i equals to smaller value
            $i = $j;
 
            do {
 
                // l equals to larger value
                $l = $i + $m;
 
                // Compare and swap arr[i] with arr[l]
                if ($arr[$i] > $arr[$l])
                {
                    $temp = $arr[$i];
                    $arr[$i] = $arr[$l];
                    $arr[$l] = $temp;
                 
                    // Decrease smaller value by step size
                    $i -= $m;
                }
                else
                    break;
                     
            } while ($i >= 0);
 
            // Increment the lower limit of i
            $j++;
 
        } while ($j <= $k);
    }
    return $arr ;
}
 
// Function to print the contents of an array
function printArray($arr, $n)
{
    for ($i = 0; $i < $n; $i++)
        echo $arr[$i], " ";
}
 
// Driver code
$arr = array( 0, -2, 8, 5, 1 );
$n = count($arr);
 
// Sort the array using Shell Metzner Sort
$result_array = sort_shell_metzner($arr, $n);
 
// Print the sorted array
printArray($result_array, $n);
 
// This code is contributed by Ryuga
?>


Javascript




<script>
 
// JavaScript implementation of Shell-Metzner Sort
 
// Function to swap two elements
    function swap(arr,i,j)
    {
        let temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        return arr;
    }
     
    // Function to sort arr[] using Shell Metzner sort    
    function sort_shell_metzner(arr,n)
    {
        // Declare variables
        let i, j, k, l, m, temp;
   
        // Set initial step size to
        // the size of the array
        m = n;
   
        while (m > 0)
        {
   
            // Step size decreases by half each time
            m = Math.floor(m/2);
   
            // k is the upper limit for j
            k = n - m;
   
            // j is the starting point
            j = 0;
   
            do
            {
   
                // i equals to smaller value
                i = j;
   
                do
                {
   
                    // l equals to larger value
                    l = i + m;
   
                    // Compare and swap arr[i] with arr[l]
                    if (l < n && arr[i] > arr[l])
                    {
                        swap(arr, i, l);
   
                        // Decrease smaller value by step size
                        i -= m;
                    }
                    else
                    {
                        break;
                    }
                } while (i >= 0);
   
                // Increment the lower limit of i
                j++;
   
            } while (j <= k);
        }
    }
     
     // Function to print the contents of an array
    function printArray(arr,n)
    {
        for (let i = 0; i < n; i++)
        {
            document.write(arr[i] + " ");
        }
    }
     
    // Driver code
    let arr=[0, -2, 8, 5, 1];
    let n = arr.length;
     
    // Sort the array using Shell Metzner Sort
    sort_shell_metzner(arr, n);
 
    // Print the sorted array
    printArray(arr, n);
 
 
// This code is contributed by avanitrachhadiya2155
 
</script>


Output: 

-2 0 1 5 8

 

Time Complexity: O(n2)
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!