归并排序和快速排序补充扩展-Go语言

基于归并排序的算法题

小和问题

在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。求一个数组 的小和。

就是在 合并的时候，当左边数组的数小于右边数组的数的时候，就开始统计当前左边数组的小和。是当前右边数组个数*当前左边数组的值。

注意：当左右数组值相等的时候。必须是合并右树组的值。

package basicsort
 
import "fmt"
 
func Small_sum_ms(arr []int) int {
 
    return process_ms(arr)
 
}
 
func process_ms(arr []int) int {
 
    if len(arr) <= 1 {
        return 0 //递归的终止条件。只有1个数，就是0
    }
 
    mid := len(arr) / 2
    // 开辟俩个数组
    l_arr := make([]int, len(arr[:mid]))
    r_arr := make([]int, len(arr[mid:]))
 
    copy(l_arr, arr[:mid])
    copy(r_arr, arr[mid:])
    // 递归调用俩个数组
 
    l_res := process_ms(l_arr)
    r_res := process_ms(r_arr)
 
    fmt.Println(l_res, r_res)
 
    l_index := 0
    r_index := 0
 
    c_index := 0
    res := 0 // 小数累加和
    for l_index < len(l_arr) && r_index < len(r_arr) {
 
        if l_arr[l_index] < r_arr[r_index] {
            //左数组的数 a 小于 右数组的数， a就是当前右树组所有数的小数，
            // res += l_arr[l_index] * (len(r_arr) - r_index + 1) //开始计算错误的地方
            res += l_arr[l_index] * (len(r_arr) - r_index)
            arr[c_index] = l_arr[l_index]
            l_index++
 
        } else {
            //右数组的数小或等于，直接合并。不需要计算
            arr[c_index] = r_arr[r_index]
            r_index++
        }
 
        // 数组越界。应该是if else。 不能if if 。l_index已经增1了。淦。。
        // if l_arr[l_index] >= r_arr[r_index] {
        //  //右数组的数小或等于，直接合并。不需要计算
        //  arr[c_index] = r_arr[r_index]
        //  r_index++
        // }
        c_index++
    }
 
    // 当只有单个数组还有数据，不需要累加
 
    for l_index < len(l_arr) {
        arr[c_index] = l_arr[l_index]
        c_index++
        l_index++
    }
 
    for r_index < len(r_arr) {
        arr[c_index] = r_arr[r_index]
        c_index++
        r_index++
    }
 
    //返回当前递归计算的结果，左数组的结果 + 右数组的结果 + 当前合并的结果
 
    return res + l_res + r_res
 
}

逆序对问题

剑指 Offer 51. 数组中的逆序对
在一个数组中，左边的数如果比右边的数大，则这两个数构成一个逆序对，请打印所有逆序 对。

也就是在合并的时候，开始计算

func reversePairs(nums []int) int {
    res := process(nums)
    return res 
}
 
func process(arr []int) int {
    if len(arr) <= 1 {
        return 0 
    }
 
    mid := len(arr) / 2 
    l_arr := make([]int, len(arr[:mid]))
    r_arr := make([]int, len(arr[mid:]))
 
    copy(l_arr, arr[:mid])
    copy(r_arr, arr[mid:])
 
    l_res := process(l_arr)
    r_res := process(r_arr)
 
    l_i, r_i, c_i := 0, 0, 0 
    res := 0
    for l_i < len(l_arr) && r_i < len(r_arr) {
 
        if l_arr[l_i] <= r_arr[r_i] {
            arr[c_i] = l_arr[l_i]
            l_i ++ 
        } else {
            res += len(l_arr) - l_i
            arr[c_i] = r_arr[r_i] 
            r_i ++ 
        }
        c_i ++
    }
 
    for l_i < len(l_arr) {
        arr[c_i] = l_arr[l_i]
        l_i++
        c_i++
 
    }
 
    for r_i < len(r_arr) {
        arr[c_i] = r_arr[r_i]
        r_i++
        c_i++
    }
 
    return l_res + r_res + res 
 
}

快速排序

根据一个数，将一个数组分成左边全部小于等于num,右边全部大于num

less: 小于等于的区域。初始值 -1
i:当前要看的数的索引
1）当[i] <= num, [i] 和 [less + 1] 交换， i++， less ++ ，此处less + 1可能是大于num的数，也可能是自己和自己交换。
2) 当[i] > num, 只有i++, 再碰到 <= num的数，就和[less + 1] 交换了。
结束条件就是数组 循环看完一遍了。

func QucikSort01(arr []int, num int) {
 
   less := -1 // 小于等于 num区域
 
   for i := 0; i < len(arr); i++ {
 
   	// 如果当前数小于 等于 num
   	if arr[i] <= num {
   		swap(arr, less+1, i) //小于等于 区域右扩
   		less++
   	}
   }
}

进阶，要分为三个区域，左边是小于 num, 中间是等于 num,右边是大于num

less: 小于num的区域，初始值-1
more: 大于num的区域，初始值len（arr）
i:当前遍历的索引
终止条件是i == more ,就是等于区域和大于区域碰着了

• 分三种情况

1）[i] < num, [less + 1] 和 [i] 交换，less ++, i++
2) [i] == num, i++
3) [i] > num, [more - 1] 和 [i] 交换，more --, i不动，因为 more-1还未看。

func QuickSort02(arr []int, num int) {
	less := -1
	more := len(arr)
	i := 0
	for i < more {
		if arr[i] < num {
			swap(arr, less+1, i)
			less++
			i++
		} else if arr[i] == num {
			i++
		} else {
			swap(arr, more-1, i)
			more--
		}
	}
}

快排

• 快排1.0 2.0 3.0 的区别
  

快排1.0

func QuickSort_10(arr []int) {
 
	partation_01(arr, 0, len(arr)-1)
}
 
func partation_01(arr []int, l int, r int) {
 
	if l >= r {
		return //递归结束条件
	}
	pv := arr[r]
	less := l - 1
	i := l
	for ; i < r; i++ {
		// 如果当前数小于 等于 num
		if arr[i] <= pv {
			swap(arr, less+1, i) //小于等于 区域右扩
			less++
		}
	}
 
	swap(arr, less+1, r) // 为啥这里需要替换呢。因为i < r ，最小区域less固定了，less +1 就是 pv的位置。
 
	// 递归调用左右数组
	partation_01(arr, l, less)
	partation_01(arr, less+2, r)
}

快排2.0

func partation_02(arr []int, l int, r int) {
 
	if l >= r {
		return //递归结束条件
	}
	pv := arr[r]
	less := l - 1
	more := r + 1
	i := l
	for i < more {
		// 如果当前数小于 等于 num
		if arr[i] < pv {
			swap(arr, less+1, i) //小于等于 区域右扩
			less++
			i++
		} else if arr[i] == pv {
			i++
		} else {
			swap(arr, i, more-1)
			more--
		}
	}
 
	if more <= r { //这里需要判断 more是否没扩。不然越界
		swap(arr, more, r) //将 pv 也就是[r] 和more区域里的第一个值替换。
	}
 
	// swap(arr, more, r) //将 pv 也就是[r] 和more区域里的第一个值替换。
 
	// 递归调用左右数组
	partation_02(arr, l, less)
	partation_02(arr, more, r)
}

快排3.0

func partation_03(arr []int, l int, r int) {
 
	if l >= r {
		return //递归结束条件
	}
	random_index := rand.Intn(r - l + 1) //随机选取一个索引
	pv := arr[l+random_index]
 
	// 将随机索引的数和最后一个数替换，下面的代码就和以前的一致了
	swap(arr, l+random_index, r)
 
	less := l - 1
	more := r + 1
	i := l
	for i < more {
		// 如果当前数小于 等于 num
		if arr[i] < pv {
			swap(arr, less+1, i) //小于等于 区域右扩
			less++
			i++
		} else if arr[i] == pv {
			i++
		} else {
			swap(arr, i, more-1)
			more--
		}
	}
	if more <= r {
		swap(arr, more, r) //将 pv 也就是[r] 和more区域里的第一个值替换。
	}
 
	// 递归调用左右数组
	partation_03(arr, l, less)
	partation_03(arr, more, r)
}

好了ok.完事。