冒泡排序

1. 原地排序算法。空间复杂度为 O(1)。
2. 稳定的排序算法。当有相邻的两个元素大小相等的时候，我们不做交换
3. 时间复杂

插入排序

1. 原地排序算法。空间复杂度为 O(1)。
2. 稳定的排序算法。
3. 时间复杂度，最好O(n)，最坏是O(n平方)

插入排序核心思想

把数组分成排序 和 未排序 两部分，取未排序部分的元素，插入到已排序合适位置。

package main

import (
	"testing"
)

// 冒泡排序（Bubble Sort）
func bubbleSort(nums []int) []int {
	if len(nums) < 2 {
		return nums
	}

	for i := 0; i < len(nums); i++ {
		flag := false
		for j := 1; j < len(nums)-i; j++ {
			if nums[j-1] > nums[j] {
				nums[j-1], nums[j] = nums[j], nums[j-1]
				flag = true // 表示有数据交换
			}
		}
		if !flag {
			break
		}
	}
	return nums
}

// 插入排序（Insertion Sort）
func insertionSort(nums []int) []int {
	if len(nums) <= 1 {
		return nums
	}

	for i := 1; i < len(nums); i++ {
		value := nums[i]
		j := i - 1
		for ; j >= 0; j-- {
			if nums[j] > value {
				nums[j+1] = nums[j]
			} else {
				break
			}
		}
		// 注意：相对于nums[j+1] = nums[j]，已经又走了一论，现在的j比最后一个这行表达式里的j小1，所以再加1才是现在的j
		nums[j+1] = value
	}

	return nums
}

func TestName(t *testing.T) {
	tests := []struct {
		nums     []int
		expected []int
	}{
		{[]int{5, 4, 3, 2, 1}, []int{1, 2, 3, 4, 5}},
		{[]int{4, 5, 6, 1, 3, 2}, []int{1, 2, 3, 4, 5, 6}},
		{[]int{1}, []int{1}},
		{[]int{}, []int{}},
	}
	for _, tt := range tests {
		actual := insertionSort(tt.nums)
		isPass := true
		if len(actual) != len(tt.expected) {
			t.Errorf("sorted failed. expect: %v, actual: %v", tt.expected, actual)
			continue
		}
		for i := 0; i < len(actual); i++ {
			if tt.expected[i] != actual[i] {
				isPass = false
				break
			}
		}
		if !isPass {
			t.Errorf("sorted failed. expect: %v, actual: %v", tt.expected, actual)
		}
	}
}