Question

我不确定为什么对于left = 0，mid = 0和right = 1合并操作的左大小和右大小似乎不起作用，因为这些计算左数组和右数组的切片没有任何意义mergesort算法假定这些数组之一必须具有值才能使其甚至位于代码的合并部分中。这导致索引错误：（

https://play.golang.org/p/Fmj4xNQTL8W

package main

import (
    "fmt"
)

func merge(arr []int, l, mid, r int) {
    leftSize := mid - l + 1
    rightSize := r - mid

    left := arr[l:mid]
    right := arr[mid+1 : r]

    fmt.Printf("l:%v, m:%v, r:%v\n", l, mid, r)
    fmt.Printf("left: size:%v arr:%v, right: size:%v arr:%v\n", leftSize, l, rightSize, r)

    /*
        i = left array pointer
        j = right array pointer
        k = original array pointer
    */
    i, j, k := 0, 0, l

    for i < leftSize && j < rightSize {
        if left[i] <= right[j] {
            arr[k] = left[i]
            i++
            k++
        } else {
            arr[k] = right[j]
            j++
            k++
        }
    }

    for i < leftSize {
        arr[k] = left[i]
        i++
        k++
    }
    for j < rightSize {
        arr[k] = right[j]
        j++
        k++
    }
}

func mergeSort(arr []int, left, right int) {
    if left >= right {
        return
    }

    // mid done this way to avoid overflows
    mid := left + (right-left)/2

    mergeSort(arr, left, mid)
    mergeSort(arr, mid+1, right)
    merge(arr, left, mid, right)
}

func main() {
    tc := []int{99, 212, 23, 3, 1, 10}
    mergeSort(tc, 0, len(tc)-1)
    fmt.Printf("%v", tc)
}

Answer 1

我有几点建议：

数组范围。 Dijkstra曾经争论过数组范围（或Go中的切片范围）应该是什么样的：对于l[i:j]的表示法，您希望它具有所有这些属性：
- 它应该从i开始。
- 计算长度应该很简单：len(l[i:j]) == j-i始终为真
- 表达一个空范围应该很优雅，所以i<=j总是正确的

因此，将l [i：j]设置为半开范围：[i，j]，包括下限，而排除上限。这也是Go切片（以及Python和许多其他语言）工作的方式。

重点是，最好将此代码保留在代码中：在进行范围调整时，请包含下限并排除上限。

切片内置于Go中。您可以利用它，而且价格便宜。您无需以冗长且容易出错的方式来计算所有这些l，r，mid，只需要对slice进行切片。

例如：

func mergeSort(arr []int) {
    size := len(arr)

    if size <= 1 {
        return
    }
    mid := size / 2
    mergeSort(arr[:mid])
    mergeSort(arr[mid:])
    merge(arr, arr[:mid], arr[mid:])
}

代码更清晰，更健壮。

切片不会进行深度复制，这意味着left := arr[l:mid]仅创建指向arr元素的指针。这就是为什么我说Go中切片便宜。

但是，如果没有深层副本，则在合并切片时，数据将被覆盖并因此被破坏。您需要合并成一个新的切片，然后将其复制回原始切片。这就是为什么朴素的mergesort被认为有O(n)额外的内存使用。

func merge(arr, left, right []int) {
    res := make([]int, len(arr))
    leftSize, rightSize := len(left), len(right)

    var i,j,k int
    for i = range res {
        if j >= leftSize || k >= rightSize {
            break
        }

        if left[j] <= right[k] {
            res[i] = left[j]
            j++
        } else {
            res[i] = right[k]
            k++
        }
    }

    // Only one of these two copies run, so no need to increase i
    copy(res[i:], left[j:])
    copy(res[i:], right[k:])

    copy(arr, res)
}

游乐场：https://play.golang.org/p/LlJj-JycfYE

Answer 2

没有完整的答案，但有一些建议：

您可以通过更改切片索引来避免恐慌：

之前：

    left := arr[l : mid]
    right := arr[mid+1 : r]

之后：

    left := arr[l : mid+1]
    right := arr[mid : r]

您可以打印左右数组内容，以调试每个步骤中发生的情况。打印尺寸并没有看到内容有用。

之前：

fmt.Printf("left: size:%v arr:%v, right: size:%v arr:%v\n", leftSize, l, rightSize, r)

之后：

fmt.Printf("left: size:%v arr:%v, right: size:%v arr:%v\n", left, l, right, r)

Mergesort无法正确计算1的左右大小

2 个答案: