go语言实现排序算法2 | 青训营笔记

冒泡排序（Bubble Sort）和快速排序（Quick Sort）是两种常见的排序算法，其中冒泡排序是一种简单的比较排序算法，而快速排序则是一种高效的分治排序算法。下面我将分别介绍这两种算法，并说明它们的实现原理和时间复杂度。

冒泡排序是一种通过多次比较和交换相邻元素来实现排序的算法。它的基本思想是从待排序的元素中依次比较相邻的两个元素，如果它们的顺序错误就交换它们，直到所有元素都排好序为止。

冒泡排序的实现过程如下：

1. 从待排序的元素中，依次比较相邻的两个元素，如果前面的元素大于后面的元素，则交换它们的位置。
2. 继续比较下一对相邻元素，重复步骤1，直到所有元素都排好序。

冒泡排序的时间复杂度为O(n^2)，其中n是待排序元素的个数。它的空间复杂度为O(1)，因为它只需要一个额外的变量来进行元素交换。

快速排序是一种高效的分治排序算法，它的基本思想是通过选择一个基准元素，将待排序的元素分割成两部分，一部分元素都小于等于基准元素，另一部分元素都大于基准元素，然后对这两部分元素分别进行递归排序。

快速排序的实现过程如下：

1. 选择一个基准元素，可以是待排序元素中的任意一个元素。
2. 将待排序元素分割成两部分，一部分元素都小于等于基准元素，另一部分元素都大于基准元素。
3. 对这两部分元素分别进行递归排序，直到每个部分只有一个元素或为空。

快速排序的时间复杂度为O(nlogn)，其中n是待排序元素的个数。在平均情况下，快速排序的性能是最好的。它的空间复杂度为O(logn)，因为它需要递归调用栈来保存每一层的状态。

以下是Go语言实现冒泡排序和快速排序的示例代码：

// 冒泡排序
func bubbleSort(arr []int) {
    n := len(arr)
    for i := 0; i < n-1; i++ {
        for j := 0; j < n-i-1; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }
}

// 快速排序
func quickSort(arr []int, low, high int) {
    if low < high {
        pivot := partition(arr, low, high)
        quickSort(arr, low, pivot-1)
        quickSort(arr, pivot+1, high)
    }
}

func partition(arr []int, low, high int) int {
    pivot := arr[high]
    i := low - 1
    for j := low; j < high; j++ {
        if arr[j] <= pivot {
            i++
            arr[i], arr[j] = arr[j], arr[i]
        }
    }
    arr[i+1], arr[high] = arr[high], arr[i+1]
    return i + 1
}

以上是冒泡排序和快速排序在Go语言中的实现示例。你可以根据需要调用这些函数来排序整数数组。请注意，这只是基本的实现示例，可能需要根据具体的需求进行修改和优化。