GO Program to Implement Shell Sort

Here we are explaining how to write a GO program to implement a sorting algorithm. There are different types of sorting methods. In this case, we use a shell sort for sorting elements in an array.

We can say the Shell sort is an extended version of the insertion sort. Both algorithms are comparison-based and in-place sorting algorithms.  Shell sort is an efficient sorting algorithm for medium-sized data sets.

Most of the part of shell sort is based on insertion sort. In insertion sort, whenever an element has to be moved far ahead, we move elements only one position ahead and it involved many movements to move an element to a far-away position. It will increase the algorithm's execution time. But in the case of shell sort, It can overcome this drawback of insertion sort. Because shell sort allows the exchange of far items. That means it avoids large shifts as in the case of insertion sort. 

How to implement shell sort

In this GO program, we are importing the “fmt” package to include some standard libraries into the program. We accept the user's values using the fmt.scanln()  and fmt.println()  methods which are defined under the fmt package. In order to use these functions, we need to import the “fmt” package. After that Main function starts, inside the main, we are doing the whole program.

As we can see, the shell sort algorithm first does sort the elements that are far away from each other, and then it subsequently reduces the gap between them. This gap is called an interval. This interval can be calculated by using Knuth's formula given below,

Knuth’s Formula :
h = h * 3 + 1
where "h" is an interval with an initial value as1

In this program, variable A holds the array elements. Another variable n is used as the size of the array. Read array elements by using for loop. Perform shell sort by calling function shellSort(A, n). Here, the function shellSort(A, n) perform the following things such as Initialize the value of interval, divide the array into smaller sub-array of the equal interval, sort these sub-array using insertion sort and repeat this process until the complete array is sorted.

Given below are the steps that are used in the Go program to implement Shell Sort.

ALGORITHM

STEP 1: Import the packages 'fmt'.
STEP 2: Open the main() to start the program, GO program execution starts with the main()
STEP 3: Declare the variable n.
STEP 4: Read the size of the array as n
STEP 5: Define the array A[]
STEP 6: Read the A[] array elements by using a 'for loop'.
STEP 7: Perform shell sort by calling function shellSort(A, n).
STEP 8: Use for loop to display sorted array.
STEP 9: Exit

Steps to Implement shellSort(A, n)

STEP 1: Open the first loop to perform shell sort and compare the element at 0 indexes to the element at n/2 index. Here n/2 index is stored in the variable interval.
STEP 2:If the loop condition: element at 0 indexes is greater than the element at interval is true, then do step 3 otherwise, go to step 8.
STEP 3: Open the outer loop for insertion sort by using for loop, which uses the loop variable j by assigning j=interval.
STEP 4: If the outer loop satisfies the condition, j<n,then it will help you to iterate over the array interval elements from left to right till the end of the array. Otherwise, go to step 7.
STEP 5: If the inner loop satisfies the sorting condition: k >= interval && A[k-interval] > A[k], then swap the values of elements. Otherwise, increment j=j+1 and Go to step 4.
STEP 6: Repeat step 5 by decrement the value of k as k=k-interval.
STEP7: Set interval = interval /2 and go to step 2
STEP 8:  Return sorted array A

GO Source Code

                                          package main
import "fmt"
func main() {
    fmt.Println("Enter the size of the array")
 var n int
 fmt.Scan(&n)
 A := make([]int, n, 100)
fmt.Println("Enter elements of the array : ")

 for i := 0; i < n; i++ {
  fmt.Scan(&A[i])
 }
fmt.Println("Sorted array:")
   fmt.Println(shellSort(A, n))

}

func shellSort(A []int, n int) []int {

    for interval := int(n/2); intervel > 0; interval /= 2 {
     for j := interval; j < n; j++ {
      for k := j; k >= interval && A[k-intervel] > A[k]; k -= interval {
       A[k], A[k-interval] = A[k-interval], A[k]
      }
     }
    }
return A
    
}

                                      

OUTPUT

Enter the size of the array
5
Enter elements of the array : 
32
24
56
85
13
Sorted array:
[13 24 32 56 85]