Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Golang program to sort a slice of integers using merge sort with concurrency
In this article, we will write Go language programs to sort a slice of integers using merge sort with concurrency. It is a process which makes the parts of a program run independently and parallelly enhancing the efficiency of the program. Go routines and channels are used to execute concurrency.
Merge sort is a divide and conquer algorithm used to sort the unsorted array or slice by dividing the input slice into smaller sub-slices, individually sort them recursively and then merge them into a single slice which is sorted.
Syntax
func make ([] type, size, capacity)
The make function in go language is used to create an array/map it accepts the type of variable to be created, its size and capacity as arguments.
Algorithm
This program imports main, fmt and sync package in the program.
Create a function named merge_integers which takes two slices left and right as arguments which will be merged into a single sorted slice.
In this step, create a slice named output with the length equal to the sum of the lengths of left and right slice.
Then, initialize two variables named i and j to 0 which represent the indices of the left and right slices.
In this step, use a for loop to sort the slice of integers.
Compare the elements at indices i and j in left and right and if left is less than right assign the smaller value to output[i+j].
Then, increment the index if less is less than right and j if right is less than left.
It continues this process until one of the slices is completely traversed.
After the loop is traversed, there might be some elements left in left or right slice which are later checked using if-else conditional and added to the resultant slice.
Finally, it returns the outputt slice, which contains the merged and sorted elements from left and right.
Create a merge Sort function to perform concurrency with the nums as parameter which denotes the slice to be sorted.
In this step, check If the length of the input slice is less than or equal to 1 return the input slice as it is already sorte.
Then, calculate the middle index of the nums slice and assign it to the mid variable.
In this step, create two empty slices, left and right, to store the left and right halves of the slices.
Then, initialize a sync.Wait Group and add a count of 2 to it using the Add method, as there will be two go routines running concurrently.
Then, use anonymous functions to create two go routines.
In the first go routine sort the left half of nums by recursively calling merge Sort on the slice nums[:mid] and store the output in the left slice.
In the second go routine sorts the right half of nums by recursively calling merge Sort on the slice nums[mid:] and stores the output in the right slice.
Use Wait method to wait for the go routines to complete the process.
After the go routines complete and the Wait Group counter reaches 0, merge the sorted left and right slices using the merge function and return the output.
Create a main function.
In the main create an unsorted slice of integers and store it inside the slice variable.
Then, call the merge Sort function on this slice to sort it.
Finally,tThe sorted result is printed to the console using the Println function from the fmt package.
Example
In this example, we will write a Go language program to sort a slice of integers by using go routines and channels with merge sort algorithm to implement concurrency.
package main
import (
"fmt"
"sync"
)
func merge_integers(left, right []int) []int {
output := make([]int, len(left)+len(right))
i, j := 0, 0
for i < len(left) && j < len(right) {
if left[i] <= right[j] {
output[i+j] = left[i]
i++
} else {
output[i+j] = right[j]
j++
}
}
for i < len(left) {
output[i+j] = left[i]
i++
}
for j < len(right) {
output[i+j] = right[j]
j++
}
return output
}
func mergeSort(nums []int) []int {
if len(nums) <= 1 {
return nums
}
mid := len(nums) / 2
var left, right []int
var wg sync.WaitGroup
wg.Add(2)
go func() {
left = mergeSort(nums[:mid])
wg.Done()
}()
go func() {
right = mergeSort(nums[mid:])
wg.Done()
}()
wg.Wait()
return merge_integers(left, right)
}
func main() {
slice := []int{90, 50, 10, 30, 80, 40, 20, 70, 60}
fmt.Println("Unsorted:", slice)
sorted := mergeSort(slice)
fmt.Println("Sorted:", sorted)
}
Output
Unsorted: [90 50 10 30 80 40 20 70 60] Sorted: [10 20 30 40 50 60 70 80 90]
Conclusion
We compiled and executed the program of sorting a slice of integers using merge sort by implementing concurrency with the help of an example which uses Go routine and channels. Hence, the program executed successfully.
94 Views
