Go语言归并排序Merge函数中的Slice引用陷阱与解决方案

func Merge(toSort *[]int, p, q, r int) {
    arr := *toSort
    L := arr[p:q]       // L是arr[p]到arr[q-1]的视图
    R := arr[q:r+1]     // R是arr[q]到arr[r]的视图
    // fmt.Println(L)
    // fmt.Println(R)
    i := 0
    j := 0

    for index := p; index <= r; index++ {
        if i >= len(L) {
            arr[index] = R[j] // 直接写入arr
            j += 1
            continue
        } else if j >= len(R) {
            arr[index] = L[i] // 直接写入arr
            i += 1
            continue
        }

        if L[i] > R[j] {
            // fmt.Println("right smaller")
            arr[index] = R[j] // 直接写入arr
            j += 1
            continue
        }
        if L[i] <= R[j] {
            // fmt.Println("left smaller")
            arr[index] = L[i] // 直接写入arr
            i += 1
            continue
        }
    }
}

func MergeCorrected(arr []int, p, q, r int) {
    // 1. 创建L和R的独立副本
    // 注意：Go切片作为函数参数时，本身就是引用传递（传递的是切片头部的值拷贝，但底层数组是共享的）。
    // 所以这里的arr不需要指针，直接传递即可。
    // 但是L和R需要是独立的数据副本，而不是arr的视图。

    // 复制左半部分到L
    leftLen := q - p
    L := make([]int, leftLen)
    copy(L, arr[p:q]) 

    // 复制右半部分到R
    rightLen := r - q + 1 // 注意这里R的长度计算
    R := make([]int, rightLen)
    copy(R, arr[q:r+1])

    i := 0 // L的当前索引
    j := 0 // R的当前索引
    k := p // arr的当前写入索引

    // 2. 将L和R中的元素合并到原始arr中
    for i < len(L) && j < len(R) {
        if L[i] <= R[j] {
            arr[k] = L[i]
            i++
        } else {
            arr[k] = R[j]
            j++
        }
        k++
    }

    // 3. 将剩余的L元素复制到arr
    for i < len(L) {
        arr[k] = L[i]
        i++
        k++
    }

    // 4. 将剩余的R元素复制到arr
    for j < len(R) {
        arr[k] = R[j]
        j++
        k++
    }
}

func MergeWithTempResult(arr []int, p, q, r int) {
    // 复制左半部分和右半部分到独立的临时切片
    left := make([]int, q-p)
    copy(left, arr[p:q])

    right := make([]int, r-q+1)
    copy(right, arr[q:r+1])

    merged := make([]int, r-p+1) // 创建一个临时切片存储合并结果

    i, j, k := 0, 0, 0 // i for left, j for right, k for merged

    for i < len(left) && j < len(right) {
        if left[i] <= right[j] {
            merged[k] = left[i]
            i++
        } else {
            merged[k] = right[j]
            j++
        }
        k++
    }

    for i < len(left) {
        merged[k] = left[i