Go Sort Examples

View code

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func bubbleSorter(integers [11]int) {

	var num = 11

	var isSwapped bool

	isSwapped = true

	for isSwapped {
		isSwapped = false
		var i int
		for i = 1; i < num; i++ {
			if integers[i-1] > integers[i] {

				var temp = integers[i]
				integers[i] = integers[i-1]
				integers[i-1] = temp
				isSwapped = true
			}

		}
	}

	fmt.Println(integers)

}

func SelectionSorter(elements []int) {

	var i int
	for i = 0; i < len(elements)-1; i++ {

		var min int
		min = i
		var j int
		for j = i + 1; j <= len(elements)-1; j++ {
			if elements[j] < elements[min] {
				min = j
			}
		}
		swap(elements, i, min)
	}

}

func swap(elements []int, i int, j int) {
	var temp = elements[j]
	elements[j] = elements[i]
	elements[i] = temp
}

func randomSequence(num int) []int {

	var sequence []int = make([]int, num)
	rand.Seed(time.Now().UnixNano())

	var i int
	for i = 0; i < num; i++ {
		sequence[i] = rand.Intn(999) - rand.Intn(999)
	}

	return sequence
}

func InsertionSorter(elements []int) {

	var n = len(elements)
	var i int

	for i = 1; i < n; i++ {

		var j int
		j = i
		for j > 0 {
			if elements[j-1] > elements[j] {
				elements[j-1], elements[j] = elements[j], elements[j-1]

			}
			j = j - 1
		}
	}

}

func ShellSorter(elements []int) {

	var (
		n         = len(elements)
		intervals = []int{1}
		k         = 1
	)

	for {

		var interval = power(2, k) + 1
		if interval > n-1 {
			break
		}

		intervals = append([]int{interval}, intervals...)
		k++

	}
	var interval int

	for _, interval = range intervals {

		var i int
		for i = interval; i < n; i += interval {
			var j int
			j = i
			for j > 0 {
				if elements[j-interval] > elements[j] {
					elements[j-interval], elements[j] = elements[j], elements[j-interval]
				}
				j = j - interval
			}
		}

	}

}

func power(exponent int, index int) int {

	var power = 1
	for index > 0 {
		if index&1 != 0 {
			power *= exponent
		}

		index >>= 1
		exponent *= exponent
	}
	return power
}

func createArray(num int) []int {
	var array []int = make([]int, num)
	rand.Seed(time.Now().UnixNano())
	var i int
	for i = 0; i < num; i++ {
		array[i] = rand.Intn(99999) - rand.Intn(99999)
	}
	return array
}

func MergeSorter(array []int) []int {

	if len(array) < 2 {
		return array
	}
	var middle int = (len(array)) / 2
	return JoinArrays(MergeSorter(array[:middle]), MergeSorter(array[middle:]))
}

func JoinArrays(leftArr []int, rightArr []int) []int {

	var num int
	var i int
	var j int
	num, i, j = len(leftArr)+len(rightArr), 0, 0
	var array []int = make([]int, num)

	var k int
	for k = 0; k < num; k++ {
		if i > len(leftArr)-1 && j <= len(rightArr)-1 {
			array[k] = rightArr[j]
			j++
		} else if j > len(rightArr)-1 && i <= len(leftArr)-1 {
			array[k] = leftArr[i]
			i++
		} else if leftArr[i] < rightArr[j] {
			array[k] = leftArr[i]
			i++
		} else {
			array[k] = rightArr[j]
			j++
		}
	}
	return array
}

func QuickSorter(elements []int, below int, upper int) {

	if below < upper {

		var part int = divideParts(elements, below, upper)

		QuickSorter(elements, below, part-1)
		QuickSorter(elements, part+1, upper)
	}

}

func divideParts(elements []int, below int, upper int) int {

	var center int = elements[upper]
	var i int = below
	var j int
	for j = below; j < upper; j++ {

		if elements[j] <= center {
			qswap(&elements[i], &elements[j])
			i += 1
		}
	}
	qswap(&elements[i], &elements[upper])
	return i
}

func qswap(element1 *int, element2 *int) {
	var val = *element1

	*element1 = *element2
	*element2 = val
}
func main() {
	var integers [11]int = [11]int{31, 13, 12, 4, 18, 16, 7, 2, 3, 0, 10}

	fmt.Println("Bubble Sorter")
	bubbleSorter(integers)

	var elements = []int{11, 4, 18, 6, 19, 21, 71, 13, 15, 2}
	fmt.Println("Before Selection Sorting ", elements)
	SelectionSorter(elements)
	fmt.Println("After Selection  Sorting ", elements)

	var sequence []int = randomSequence(24)
	fmt.Println("\n^^^^^^ Before Insertion Sorting ^^^ \n\n", sequence)

	InsertionSorter(sequence)
	fmt.Println("\n--- After Insertion  Sorting ---\n\n", sequence)

	var selements []int = []int{34, 202, 13, 19, 6, 5, 1, 43, 506, 12, 20, 28, 17, 100, 25, 4, 5, 97, 1000, 27}
	ShellSorter(selements)
	fmt.Println(selements)

	var melements []int = createArray(40)
	fmt.Println("\n Before Sorting \n\n", melements)
	fmt.Println("\n-After Sorting\n\n", MergeSorter(melements))

	var num int
	fmt.Print("Enter Number of Elements: ")
	fmt.Scan(&num)

	var array = make([]int, num)

	var i int
	for i = 0; i < num; i++ {
		fmt.Print("array[", i, "]: ")
		fmt.Scan(&array[i])
	}

	fmt.Print("Elements before qsort: ", array, "\n")
	QuickSorter(array, 0, num-1)
	fmt.Print("Elements after qsort: ", array, "\n")

}