1. 基础排序算法——冒泡排序（golang）

冒泡排序

冒泡排序是一种交换排序，它的基本思想是相邻的元素进行比较交换。

代码实现

package bubbleSort

import (
	"errors"
	"fmt"
)

// 冒泡排序找最大
func BubbleFindMax(arr []int) (max int, err error) {

	// 数组长度
	length := len(arr)

	// 空数组
	if length == 0 {
		err = errors.New("空数组")
		return
	}

	if length == 1 {
		max = arr[0]
		return
	}

	// 遍历，两两比较
	for i := 0; i < length-1; i++ {
		if arr[i] > arr[i+1] {
			arr[i], arr[i+1] = arr[i+1], arr[i]
		}
	}

	max = arr[length-1]
	return
}

func BubbleSort(arr []int) []int {

	// 数组长度
	length := len(arr)
	if length <= 1 {
		return arr
	}

	// 遍历
	for i := 0; i < length-1; i++ {
	
		// 标记，如果循环了一遍没有发生交换，则代表数组已经有序了，不用再排序
		flag := false

		for j := 0; j < length-1-i; j++ {
			// 两两交换
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
				flag = true
			}
			fmt.Println(i, ":", arr)
		}

		if !flag {
			break
		}
	}

	return arr

}

时间复杂度

最好的情况，元素都是有序的，只需要遍历n-1次，则时间复杂度为O(n)。

最坏的情况，全部元素都要交换，则时间复杂度为O(n^2)。

稳定性

冒泡排序是一种稳定排序算法。

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。