Pointers Golang：将切片作为参考问题传入

我正试图编写一个程序来计算数组中的反转数，但是由于引用问题，我的数组没有被正确排序，因此，即使我认为切片在Golang中是通过引用传递的，也会弄乱我的计数

这是我的密码：

package main

import (
    "fmt"
)

func InversionCount(a []int) int {
    if len(a) <= 1 {
        return 0
    }
    mid := len(a) / 2
    left := a[:mid]
    right := a[mid:]
    leftCount := InversionCount(left) //not being sorted properly due to reference issues 
    rightCount := InversionCount(right) //not being sorted properly due to reference issues

    res := make([]int, 0, len(right)+len(left)) //temp slice to hold the sorted left side and right side

    iCount := mergeCount(left, right, &res)

    a = res        //assigns the original slice with the temp slice values
    fmt.Println(a) //a in the end is not sorted properly for most cases 
    return iCount + leftCount + rightCount
}

    func mergeCount(left, right []int, res *[]int) int {
        count := 0

        for len(left) > 0 || len(right) > 0 {
            if len(left) == 0 {
                *res = append(*res, right...)
                break
            }
            if len(right) == 0 {
                *res = append(*res, left...)
                break
            }
        if left[0] <= right[0] {
            *res = append(*res, left[0])
            left = left[1:]
        } else { //Inversion has been found
            count += len(left)
            *res = append(*res, right[0])
            right = right[1:]
        }
    }

    return count
}

func main() {
    test := []int{4,2,3,1,5}
    fmt.Print(InversionCount(test))
}

主程序包
进口(
“fmt”
)
func InversionCount（a[]int）int{
如果len（a）0 | | len（右）>0{
如果len（左）==0{
*res=追加（*res，right…）
打破
}
如果len（右）==0{
*res=追加（*res，左…）
打破
}
如果左[0]则必须传递指向切片的指针，如：

func InversionCount(a *[]int) int {
    if len(*a) <= 1 {
        return 0
    }
    mid := len(*a) / 2
    left := (*a)[:mid]
    right := (*a)[mid:]
    leftCount := InversionCount(&left)   //not being sorted properly due to reference issues
    rightCount := InversionCount(&right) //not being sorted properly due to reference issues

    res := make([]int, 0, len(right)+len(left)) //temp slice to hold the sorted left side and right side

    iCount := mergeCount(left, right, &res)

    *a = res
    fmt.Println(a) //a in the end is not sorted properly for most cases
    return iCount + leftCount + rightCount
}

func InversionCount（a*[]int）int{
如果len（*a）没有对切片进行变异，我只希望函数返回在合并步骤中获得的切片

下面是这种形式的代码，包括一些类似单元测试的代码，这些代码将有效版本与天真的O（N^2）计数进行比较

主程序包
输入“fmt”
//Inversions返回已排序的输入，以及找到的反转数。
func逆变换（a[]int）（[]int，int）{
如果len（a）0&&len（右）>0{
如果左[0]>=右[0]{
res=追加（res，左[0]）
左=左[1:]
}否则{
res=追加（res，右[0]）
右=右[1:]
n+=len（左）
}
}
返回追加（追加（res，左…，右…，n
}
func逆（a[]int）int{
n:=0
对于i:=范围a{
对于j:=i+1；j
@DavidTrinh记得投票并标出对你有帮助的答案。
package main

import "fmt"

// Inversions returns the input sorted, and the number of inversions found.
func Inversions(a []int) ([]int, int) {
    if len(a) <= 1 {
        return a, 0
    }
    left, lc := Inversions(a[:len(a)/2])
    right, rc := Inversions(a[len(a)/2:])
    merge, mc := mergeCount(left, right)
    return merge, lc + rc + mc
}

func mergeCount(left, right []int) ([]int, int) {
    res := make([]int, 0, len(left)+len(right))
    n := 0
    for len(left) > 0 && len(right) > 0 {
        if left[0] >= right[0] {
            res = append(res, left[0])
            left = left[1:]
        } else {
            res = append(res, right[0])
            right = right[1:]
            n += len(left)
        }
    }
    return append(append(res, left...), right...), n
}

func dumbInversions(a []int) int {
    n := 0
    for i := range a {
        for j := i + 1; j < len(a); j++ {
            if a[i] < a[j] {
                n++
            }
        }
    }
    return n
}

func main() {
    cases := [][]int{
        {},
        {1},
        {1, 2, 3, 4, 5},
        {2, 1, 3, 4, 5},
        {5, 4, 3, 2, 1},
        {2, 2, 1, 1, 3, 3, 4, 4, 1, 1},
    }
    for _, c := range cases {
        want := dumbInversions(c)
        _, got := Inversions(c)
        if want != got {
            fmt.Printf("Inversions(%v)=%d, want %d\n", c, got, want)
        }
    }
}