Question

所以我正在尝试编写一个方法，它接受两个切片，翻转它们然后互相给它们。

实施例

s1 = {1,2,3,4,5}

s2 = {6,7,8,9,10}

应该返回：

s1 = {10,9,8,7,6}

s2 = {5,4,3,2,1}

这是我的代码：

package main
import(
    "fmt"
)

func main(){
    f:= [5]int{1,2,3,4,5}
    h:= [5]int{6,7,8,9,10}
    var sliceF []int = f[0:5]
    var sliceH []int = h[0:5]

    fmt.Println(reverseReverse(sliceF,sliceH))

}
func reverseReverse(first []int, second []int) ([]int, []int){
    //creating temp arrays to hold the traversed arrays before swapping.
    var tempArr1 []int = first
    var tempArr2 []int = second
    //count is used for counting up the tempArrays in the correct order in the For loops
    var count  int= 0
    //goes through the first array and sets the values starting from the end equal to the temp array
    //which increases normally from left to right.
    for i :=len(first)-1; i>=0;i--{
        tempArr1[count] = first[i]
        fmt.Println(i)
        count++
    }
    count =0
    //same as first for loop just on the second array
    for i :=len(second)-1; i>=0;i--{
        tempArr2[count] = second[i]
        count++
    }
    //trying to replace the values of the param arrays to be equal to the temp arrays
    first=tempArr2
    second = tempArr1
    //returning the arrays
    return first,second
}

在此处运行时输出：

4

3

2

1

0

[10 9 8 9 10]

[5 4 3 4 5]

*我没有在for循环中包含print语句来检查索引是否正常减少。

我知道有更好的方法可以做到这一点，但为了概念证明，我想使用for循环。

任何帮助表示赞赏。我是新手，往往有java的习惯，所以我假设我的问题与此有关。

Answer 1

通过实现不需要实际交换单个元素，可以更简单地完成此操作。相反，反转每个数组并交换它们的顺序。更简单！

func reverseReverse( a, b []int ) ([]int, []int) {
    return reverse(b), reverse(a)
}

func reverse( a []int ) []int {
    end := len(a) - 1

    // Allocate a new array slice of the same length to copy to.
    ret := make( []int, len(a) )

    // Copy each element of a into ret, reversed.
    for i := range a {
        ret[end-i] = a[i]
    }

    return ret
}

有了这个启示，几乎不需要非常专业的reverseReverse功能。自己交换订单。

fmt.Println(reverse(sliceH), reverse(sliceF))

请注意，如果您只想获取一个数组，只需编写sliceH []int := h[:]而不指定开始和结束就足够了。假设开始为0，结束为结束。另请注意，无需声明类型，:=为您处理。

更好的是，您可以直接声明并初始化它们。

sliceF:= []int{1,2,3,4,5}
sliceH:= []int{6,7,8,9,10}

Answer 2

简答：

tempArr1[count] = first[i]

此行在逻辑上与：

相同

first[count] = first[i]

详细解答：

x := [5]int{}和x := []int{}实际上是两个截然不同的作业。在第一种情况下，x实际上是一个静态数组。在第二种情况下，x是切片，实际上是一种数据结构，具有长度，容量和指向底层数组的指针。因此，var tempArr1 []int = first表示将指向first的基础数组的指针复制到tempArr1，因此对first[i]的任何修改都将反映在tempArr1中，反之亦然

Answer 3

例如，

package main

import "fmt"

func reverse(s []int) []int {
    for i := 0; i < len(s)/2; i++ {
        s[i], s[len(s)-1-i] = s[len(s)-1-i], s[i]
    }
    return s
}

func main() {
    s1, s2 := []int{1, 2, 3, 4, 5}, []int{6, 7, 8, 9, 10}
    fmt.Println(s1, s2)
    s1, s2 = reverse(s2), reverse(s1)
    fmt.Println(s1, s2)
}

输出：

[1 2 3 4 5] [6 7 8 9 10]
[10 9 8 7 6] [5 4 3 2 1]

使用for循环逻辑错误翻转切片

3 个答案: