Go The Way 之 冒泡排序、快速排序、插入排序、選擇排序

排序是最常見的算法

• 冒泡排序

func BubbleSort(nums []int) []int {
	length := len(nums)
	for i := 0; i < length; i++ {
		for j := 0; j < i; j++ {
			if nums[i] > nums[j] {
				nums[i], nums[j] = nums[j], nums[i]
			}
		}
	}

	return nums
}

• 選擇排序

// 選擇排序
func SelectSort(nums []int) []int {
	length := len(nums)
	max, maxindex := 0, 0

	for i := 0; i < length-1; i++ {
		max = nums[i]
		maxindex = i
		for j := i + 1; j < length; j++ {
			if nums[j] > max {
				max = nums[j]
				maxindex = j
			}
		}

		if maxindex != i {
			nums[i], nums[maxindex] = nums[maxindex], nums[i]
		}
	}

	return nums
}

• 插入排序

// 插入排序： 屬於內部排序法，是對於預排序的元素以插入的方式找尋該元素的適當位置，以2達到排序的目的
/**
思想：把n個待排序的元素看成爲一個有序表和一個無序表，開始時有序表中只包含一個元素，無序表中有n-1個元素，排序過程中每次從無序表中取出
第一個元素，把他的排序碼依次與有序表元素的排序碼進行比較，將她插入到有序表中的適當位置，使之成爲新的有序表
*/
func InsertSort(nums []int) []int {
	for i := 1; i < len(nums); i++ {
		insertVal := nums[i]
		insertIndex := i - 1
		for insertIndex >= 0 && nums[insertIndex] <= insertVal {
			nums[insertIndex+1] = nums[insertIndex]
			insertIndex--
		}
		// 插入
		if insertIndex+1 != i {
			nums[insertIndex+1] = insertVal
		}
		fmt.Printf("第%d次插入後的數據爲%v\n", i, nums)
	}
	return nums

}

• 快速排序

//快速排序法
/**
快速排序是對冒泡排序的改進，通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，
然後再按此方法對該兩部分數據分別進行快速排序，整個排序的過程可以遞歸進行，以此達到整個數據編程有序序列
*/

//快速排序
func QuickSort(arr []int, left, right int) []int {

	pivot := 0

	if left < right {

		pivot = partition(arr, left, right)

		QuickSort(arr, left, pivot-1)

		QuickSort(arr, pivot+1, right)

	}
	return arr
}

func partition(arr []int, left, right int) int {

	key := arr[left]

	for left < right {

		for left < right && arr[right] <= key {

			right--

		}

		arr[left] = arr[right]

		for left < right && arr[left] >= key {

			left++

		}

		arr[right] = arr[left]

	}

	arr[left] = key

	return left

}

快速排序步驟詳解可見：傳送門