常用算法实现【必会】：sort/bfs/dfs

常用排序算法实现（Go版本）

// 冒泡
void maopao_sort(int *array, int len)
{
   
	int i, j, tmp;
	for (i = 0; i < len; i++)
	{
   
		for (j = i + 1; j < len; j++)
		{
   
			if (array[i] > array[j])
			{
   
				tmp = array[i];
				array[i] = array[j];
				array[j] = tmp;
			}
		}
	}
}

// 快排（分治）
// 时间复杂度：O(nlogn) 空间复杂度：O(logn)
func QuickSort(arr []int, left, right int) {
   
	var QuickSorting = func(arr []int, left, right int) int {
   
		tmp := arr[right] // 1、从右向左依次选基准值tmp
		for left < right {
   
			for arr[left] <= tmp && left < right {
    // 2、每轮循环中先从左向右，遇到比基准值小的数则left++
				left++
			}
			if left < right {
   
				arr[right] = arr[left] // 3、直至遇到比基准值大的数x=array[left]为止，然后再交换基准值与较大值x的位置（保证基准值左侧的值都比基准值tmp小）
			}
 
			for arr[right] >= tmp && left < right {
    // 4、每轮循环中再从右向左，遇到比基准值大的数则right--
				right--
			}
			if left < right {
    // 5、直至遇到比基准值小的数y=array[right]为止，然后再交换基准值与较小值y的位置（保证基准值右侧的值都比基准值tmp大）
				arr[left] = arr[right]
			}
		}
 
		arr[left] = tmp
		return left
	}
 
	if left < right {
   
		mid := QuickSorting(arr, left, right)
		QuickSort(arr, left, mid-1)
		QuickSort(arr, mid+1, right)
	}
}
 
// 快排（非递归）// todo:待补充
// https://www.bilibili.com/video/av758822583/?vd_source=2c268e25ffa1022b703ae0349e3659e4
func QuickSortNotByRecursion(arr []int) {
   
}
 
// 堆排（大顶堆：每个节点的值都大于或等于其左右孩子节点的值）
// 时间复杂度：O(nlogn) 空间复杂度：O(1)
func HeapSort(arr []int) {
   
	var CreateHeap = func(arr []int, i, length int) {
   
		tmp := arr[i]
 
		// 注意for循环条件：是 j<length 而不是 j<len(arr)
		for j := 2*i + 1; j < length; j = j*2 + 1 {
    // j=2i+1:当前根节点的左孩子下标 j= 2*j + 1:以当前叶子节点为新根节点，该新根节点的下一层叶子节点左孩子下标
			if j+1 < length && arr[j]