常见的几种排序算法(golang实现)

冒泡排序

package sort

import (
	"fmt"
	"testing"
)

func TestBubbleSort(t *testing.T) {
	bubbleSort([]int{4, 5, 6, 1, 7, 3})
}

func bubbleSort(arr []int) {
	if arr == nil || len(arr) < 2 {
		return
	}
	
	length := len(arr)
	for e := length - 1; e > 0; e-- {
		for i := 0; i < e; i++ {
			if arr[i] > arr[i+1] {
				arr[i], arr[i+1] = arr[i+1], arr[i]
			}
		}
	}
	fmt.Println(arr)
}

插入排序

package sort

import (
	"fmt"
	"testing"
)

func TestInsertionSort(t *testing.T) {
	insertionSort([]int{5, 4, 6, 2, 4, 1})
}

func insertionSort(arr []int) {
	if arr == nil || len(arr) < 2 {
		return
	}
	length := len(arr)
	for i := 1; i < length; i++ {
		for j := i - 1; j >= 0 && arr[j] > arr[j+1]; j-- {
			arr[j], arr[j+1] = arr[j+1], arr[j]
		}
	}
	fmt.Println(arr)
}

选择排序

package sort

import (
	"fmt"
	"testing"
)

func TestSelectSort(t *testing.T) {
	selectSort([]int{5, 4, 6, 2, 4, 1})
}

func selectSort(arr []int) {
	if arr == nil || len(arr) < 2 {
		return
	}

	length := len(arr)
	for i := 0; i < length-1; i++ {
		minIndex := i
		for j := i + 1; j < length; j++ {
			if arr[j] < arr[minIndex] {
				minIndex = j
			}
		}
		arr[i], arr[minIndex] = arr[minIndex], arr[i]
	}
	fmt.Println(arr)
}

归并排序

package sort

import (
	"fmt"
	"testing"
)

func TestMergeSort(t *testing.T) {
	mergeSort([]int{5, 4, 6, 2, 4, 1})

}

func mergeSort(arr []int) {
	if arr == nil || len(arr) < 2 {
		return
	}
	process(&arr, 0, len(arr)-1)
	fmt.Println(arr)
}

func process(arr *[]int, L int, R int) {
	if L == R {
		return
	}
	mid := L + (R-L) >> 1
	process(arr, L, mid)
	process(arr, mid+1, R)
	merge(arr, L, mid, R)
}

func merge(a *[]int, L int, M int, R int) {
	help := make([]int, 0, R-L+1)
	p1 := L
	p2 := M + 1
	arr := *a
	for p1 <= M && p2 <= R {
		if arr[p1] <= arr[p2] {
			help = append(help, arr[p1])
			p1++
		} else {
			help = append(help, arr[p2])
			p2++
		}
	}
	for p1 <= M {
		help = append(help, arr[p1])
		p1++
	}
	for p2 <= R {
		help = append(help, arr[p2])
		p2++
	}
	length := len(help)
	for i := 0; i < length; i++ {
		arr[L+i] = help[i]
	}
}

快速排序

package sort

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

func TestQuickSort(t *testing.T) {
	startQuickSort([]int{5, 4, 6, 2, 4, 1})
}

func startQuickSort(arr []int) {
	if arr == nil || len(arr) < 2 {
		return
	}
	quickSort(&arr, 0, len(arr)-1)
	fmt.Println(arr)
}

func quickSort(arr *[]int, L int, R int) {
	if L < R {
		swap(arr, L + rand.Intn(R-L+1), R)
		p := partition(arr, L, R)
		quickSort(arr, L, p[0]-1)
		quickSort(arr, p[1]+1, R)
	}
}

func partition(a *[]int, L int, R int) []int {
	less := L - 1
	more := R
	arr := *a
	for L < more {
		if arr[L] < arr[R] {
			less++
			swap(a, less, L)
			L++
		} else if arr[L] > arr[R] {
			more--
			swap(a, more, L)
		} else {
			L++
		}
	}
	swap(a, more, R)
	res := []int{less+1, more}
	return res
}

func swap(a *[]int, i int, j int) {
	arr := *a
	arr[i], arr[j] = arr[j], arr[i]
}