Recursion 戈朗：计数反转排序问题

我最近开始尝试使用Golang。我正试图编写一个程序，计算给定切片的反转数，但我遇到了一个问题

我试图使用基于MergeSort的代码对切片进行排序，但我的代码似乎没有正确地对切片进行排序。我假设最后一个切片必须进行排序，反转计数才能正常工作，但我不知道如何做到这一点。我能在这个问题上得到一些帮助吗

func InversionCount(a []int) int {
    if len(a) <= 1 {
        return 0
    }
    mid := len(a) / 2
    left := a[:mid]
    right := a[mid:]
    leftCount := InversionCount(left)
    rightCount := InversionCount(right)

    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        //Copies the result back into the original slice
    fmt.Println(a) //Why hasn't "a" been sorted?
    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 += 1
            *res = append(*res, right[0])
            right = right[1:]
        }
    }

    return count
}

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

func InversionCount（a[]int）int{
如果len（a）您需要更换线路

count += 1

与

关键是，在
mergeCount
中的任何一点上，如果
left[0]>right[0]
，那么由于
left
已经被排序，left

中的所有剩余内容都与

right[0]

相反。如果这样做，您将得到正确的计数

排序不起作用的事实是另一个问题。如果你有兴趣解决这个问题，我建议你去掉所有的计数逻辑，试着解决排序问题。如果你仍然被卡住，它可能应该有自己的问题

一个问题是

InversionCount（arr）

不会导致

arr

被排序，因此

a = res        //Copies the result back into the original slice
fmt.Println(a) //Why hasn't "a" been sorted?

这并不是你想要的，因为之前当你将

mergeCount

应用到

left

和

right

时，那些子数组

left

和

right

并没有按

InversionCount

排序。一个简单的例子是：

package main

import "fmt"

func Foo(a []int) {
    a = []int{1, 2, 3, 4}
}

func main() {
    a := []int{4, 3, 2, 1}
    Foo(a)
    fmt.Println(a) // [4, 3, 2, 1]
}

---

你需要更换线路

count += 1

与

关键是，在

mergeCount

中的任何一点上，如果

left[0]>right[0]

，那么由于

left

已经被排序，left中的所有剩余内容都与

right[0]

相反。如果这样做，您将得到正确的计数

排序不起作用的事实是另一个问题。如果你有兴趣解决这个问题，我建议你去掉所有的计数逻辑，试着解决排序问题。如果你仍然被卡住，它可能应该有自己的问题

一个问题是

InversionCount（arr）

不会导致

arr

被排序，因此

a = res        //Copies the result back into the original slice
fmt.Println(a) //Why hasn't "a" been sorted?

这并不是你想要的，因为之前当你将

mergeCount

应用到

left

和

right

时，那些子数组

left

和

right

并没有按

InversionCount

排序。一个简单的例子是：

package main

import "fmt"

func Foo(a []int) {
    a = []int{1, 2, 3, 4}
}

func main() {
    a := []int{4, 3, 2, 1}
    Foo(a)
    fmt.Println(a) // [4, 3, 2, 1]
}

---

你需要更换线路

count += 1

与

关键是，在

mergeCount

中的任何一点上，如果

left[0]>right[0]

，那么由于

left

已经被排序，left中的所有剩余内容都与

right[0]

相反。如果这样做，您将得到正确的计数

排序不起作用的事实是另一个问题。如果你有兴趣解决这个问题，我建议你去掉所有的计数逻辑，试着解决排序问题。如果你仍然被卡住，它可能应该有自己的问题

一个问题是

InversionCount（arr）

不会导致

arr

被排序，因此

a = res        //Copies the result back into the original slice
fmt.Println(a) //Why hasn't "a" been sorted?

这并不是你想要的，因为之前当你将

mergeCount

应用到

left

和

right

时，那些子数组

left

和

right

并没有按

InversionCount

排序。一个简单的例子是：

package main

import "fmt"

func Foo(a []int) {
    a = []int{1, 2, 3, 4}
}

func main() {
    a := []int{4, 3, 2, 1}
    Foo(a)
    fmt.Println(a) // [4, 3, 2, 1]
}

---

你需要更换线路

count += 1

与

关键是，在

mergeCount

中的任何一点上，如果

left[0]>right[0]

，那么由于

left

已经被排序，left中的所有剩余内容都与

right[0]

相反。如果这样做，您将得到正确的计数

排序不起作用的事实是另一个问题。如果你有兴趣解决这个问题，我建议你去掉所有的计数逻辑，试着解决排序问题。如果你仍然被卡住，它可能应该有自己的问题

一个问题是

InversionCount（arr）

不会导致

arr

被排序，因此

a = res        //Copies the result back into the original slice
fmt.Println(a) //Why hasn't "a" been sorted?

这并不是你想要的，因为之前当你将

mergeCount

应用到

left

和

right

时，那些子数组

left

和

right

并没有按

InversionCount

排序。一个简单的例子是：

package main

import "fmt"

func Foo(a []int) {
    a = []int{1, 2, 3, 4}
}

func main() {
    a := []int{4, 3, 2, 1}
    Foo(a)
    fmt.Println(a) // [4, 3, 2, 1]
}

---

为什么你认为你需要对数组进行排序来计算倒数？我想你可能会对什么是“计算倒数”感到困惑意思是，这个链接希望有助于澄清：。你不应该在排序时计算反转吗？看起来这就是链接中的图片所显示的，因为它最后显示了一个已排序的数组。我知道我现在计算反转的方式有问题，但我想先让排序部分工作。我明白了，你正在尝试应用此处列出的“方法2”，而不是简单的不需要排序的“方法1”。为什么您认为需要对数组进行排序以计算反转数？我想您可能会对什么是“计算反转数”感到困惑意思是，这个链接希望有助于澄清：。你不应该在排序时计算反转吗？看起来这就是链接中的图片所显示的，因为它最后显示了一个已排序的数组。我知道我现在计算反转的方式有问题，但我想先让排序部分工作。我明白了，你正在尝试应用此处列出的“方法2”，而不是简单的不需要排序的“方法1”。为什么您认为需要对数组进行排序以计算反转数？我想您可能会对什么是“计算反转数”感到困惑意思是，这个链接希望有助于澄清：。你不应该在排序时计算反转吗？看起来链接中的图片就是这样显示的